Merge pull request #13 from kris7t/xtext-formatter

Xtext formatter support

11 files changed, 292 insertions, 353 deletions

diff --git a/language-web/src/main/js/editor/EditorButtons.tsx b/language-web/src/main/js/editor/EditorButtons.tsx
index 09ce33dd..150aa00d 100644
--- a/language-web/src/main/js/editor/EditorButtons.tsx
+++ b/language-web/src/main/js/editor/EditorButtons.tsx
@@ -7,6 +7,7 @@ import ToggleButtonGroup from '@mui/material/ToggleButtonGroup';
 import CheckIcon from '@mui/icons-material/Check';
 import ErrorIcon from '@mui/icons-material/Error';
 import FormatListNumberedIcon from '@mui/icons-material/FormatListNumbered';
+import FormatPaint from '@mui/icons-material/FormatPaint';
 import InfoOutlinedIcon from '@mui/icons-material/InfoOutlined';
 import RedoIcon from '@mui/icons-material/Redo';
 import SearchIcon from '@mui/icons-material/Search';
@@ -47,7 +48,6 @@ export const EditorButtons = observer(() => {
           disabled={!editorStore.canUndo}
           onClick={() => editorStore.undo()}
           aria-label="Undo"
-          value="undo"
         >
           <UndoIcon fontSize="small" />
         </IconButton>
@@ -55,7 +55,6 @@ export const EditorButtons = observer(() => {
           disabled={!editorStore.canRedo}
           onClick={() => editorStore.redo()}
           aria-label="Redo"
-          value="redo"
         >
           <RedoIcon fontSize="small" />
         </IconButton>
@@ -88,6 +87,12 @@ export const EditorButtons = observer(() => {
           {getLintIcon(editorStore.highestDiagnosticLevel)}
         </ToggleButton>
       </ToggleButtonGroup>
+      <IconButton
+        onClick={() => editorStore.formatText()}
+        aria-label="Automatic format"
+      >
+        <FormatPaint fontSize="small" />
+      </IconButton>
     </Stack>
   );
 });
diff --git a/language-web/src/main/js/editor/EditorStore.ts b/language-web/src/main/js/editor/EditorStore.ts
index 059233f4..5760de28 100644
--- a/language-web/src/main/js/editor/EditorStore.ts
+++ b/language-web/src/main/js/editor/EditorStore.ts
@@ -115,6 +115,7 @@ export class EditorStore {
         lineNumbers(),
         foldGutter(),
         keymap.of([
+          { key: 'Mod-Shift-f', run: () => this.formatText() },
           ...closeBracketsKeymap,
           ...commentKeymap,
           ...completionKeymap,
@@ -280,4 +281,9 @@ export class EditorStore {
   toggleLintPanel(): void {
     this.setLintPanelOpen(!this.showLintPanel);
   }
+
+  formatText(): boolean {
+    this.client.formatText();
+    return true;
+  }
 }
diff --git a/language-web/src/main/js/xtext/ContentAssistService.ts b/language-web/src/main/js/xtext/ContentAssistService.ts
index aa9a80b0..8b872e06 100644
--- a/language-web/src/main/js/xtext/ContentAssistService.ts
+++ b/language-web/src/main/js/xtext/ContentAssistService.ts
@@ -10,7 +10,7 @@ import escapeStringRegexp from 'escape-string-regexp';
 import { implicitCompletion } from '../language/props';
 import type { UpdateService } from './UpdateService';
 import { getLogger } from '../utils/logger';
-import type { IContentAssistEntry } from './xtextServiceResults';
+import type { ContentAssistEntry } from './xtextServiceResults';
 
 const PROPOSALS_LIMIT = 1000;
 
@@ -67,8 +67,8 @@ function computeSpan(prefix: string, entryCount: number): RegExp {
   return new RegExp(`^${escapedPrefix}$`);
 }
 
-function createCompletion(entry: IContentAssistEntry): Completion {
-  let boost;
+function createCompletion(entry: ContentAssistEntry): Completion {
+  let boost: number;
   switch (entry.kind) {
     case 'KEYWORD':
       // Some hard-to-type operators should be on top.
diff --git a/language-web/src/main/js/xtext/HighlightingService.ts b/language-web/src/main/js/xtext/HighlightingService.ts
index fc3e9e53..dfbb4a19 100644
--- a/language-web/src/main/js/xtext/HighlightingService.ts
+++ b/language-web/src/main/js/xtext/HighlightingService.ts
@@ -1,10 +1,7 @@
 import type { EditorStore } from '../editor/EditorStore';
 import type { IHighlightRange } from '../editor/semanticHighlighting';
 import type { UpdateService } from './UpdateService';
-import { getLogger } from '../utils/logger';
-import { isHighlightingResult } from './xtextServiceResults';
-
-const log = getLogger('xtext.ValidationService');
+import { highlightingResult } from './xtextServiceResults';
 
 export class HighlightingService {
   private readonly store: EditorStore;
@@ -17,13 +14,10 @@ export class HighlightingService {
   }
 
   onPush(push: unknown): void {
-    if (!isHighlightingResult(push)) {
-      log.error('Invalid highlighting result', push);
-      return;
-    }
+    const { regions } = highlightingResult.parse(push);
     const allChanges = this.updateService.computeChangesSinceLastUpdate();
     const ranges: IHighlightRange[] = [];
-    push.regions.forEach(({ offset, length, styleClasses }) => {
+    regions.forEach(({ offset, length, styleClasses }) => {
       if (styleClasses.length === 0) {
         return;
       }
diff --git a/language-web/src/main/js/xtext/OccurrencesService.ts b/language-web/src/main/js/xtext/OccurrencesService.ts
index d1dec9e9..bc865537 100644
--- a/language-web/src/main/js/xtext/OccurrencesService.ts
+++ b/language-web/src/main/js/xtext/OccurrencesService.ts
@@ -7,9 +7,9 @@ import { getLogger } from '../utils/logger';
 import { Timer } from '../utils/Timer';
 import { XtextWebSocketClient } from './XtextWebSocketClient';
 import {
-  isOccurrencesResult,
-  isServiceConflictResult,
-  ITextRegion,
+  isConflictResult,
+  occurrencesResult,
+  TextRegion,
 } from './xtextServiceResults';
 
 const FIND_OCCURRENCES_TIMEOUT_MS = 1000;
@@ -20,7 +20,7 @@ const CLEAR_OCCURRENCES_TIMEOUT_MS = 10;
 
 const log = getLogger('xtext.OccurrencesService');
 
-function transformOccurrences(regions: ITextRegion[]): IOccurrence[] {
+function transformOccurrences(regions: TextRegion[]): IOccurrence[] {
   const occurrences: IOccurrence[] = [];
   regions.forEach(({ offset, length }) => {
     if (length > 0) {
@@ -87,21 +87,32 @@ export class OccurrencesService {
       caretOffset: this.store.state.selection.main.head,
     });
     const allChanges = this.updateService.computeChangesSinceLastUpdate();
-    if (!allChanges.empty
-      || (isServiceConflictResult(result) && result.conflict === 'canceled')) {
+    if (!allChanges.empty || isConflictResult(result, 'canceled')) {
       // Stale occurrences result, the user already made some changes.
       // We can safely ignore the occurrences and schedule a new find occurrences call.
       this.clearOccurrences();
       this.findOccurrencesTimer.schedule();
       return;
     }
-    if (!isOccurrencesResult(result) || result.stateId !== this.updateService.xtextStateId) {
-      log.error('Unexpected occurrences result', result);
+    const parsedOccurrencesResult = occurrencesResult.safeParse(result);
+    if (!parsedOccurrencesResult.success) {
+      log.error(
+        'Unexpected occurences result',
+        result,
+        'not an OccurrencesResult: ',
+        parsedOccurrencesResult.error,
+      );
       this.clearOccurrences();
       return;
     }
-    const write = transformOccurrences(result.writeRegions);
-    const read = transformOccurrences(result.readRegions);
+    const { stateId, writeRegions, readRegions } = parsedOccurrencesResult.data;
+    if (stateId !== this.updateService.xtextStateId) {
+      log.error('Unexpected state id, expected:', this.updateService.xtextStateId, 'got:', stateId);
+      this.clearOccurrences();
+      return;
+    }
+    const write = transformOccurrences(writeRegions);
+    const read = transformOccurrences(readRegions);
     this.hasOccurrences = write.length > 0 || read.length > 0;
     log.debug('Found', write.length, 'write and', read.length, 'read occurrences');
     this.store.updateOccurrences(write, read);
diff --git a/language-web/src/main/js/xtext/UpdateService.ts b/language-web/src/main/js/xtext/UpdateService.ts
index 9b672e79..e78944a9 100644
--- a/language-web/src/main/js/xtext/UpdateService.ts
+++ b/language-web/src/main/js/xtext/UpdateService.ts
@@ -1,6 +1,8 @@
 import {
   ChangeDesc,
   ChangeSet,
+  ChangeSpec,
+  StateEffect,
   Transaction,
 } from '@codemirror/state';
 import { nanoid } from 'nanoid';
@@ -11,10 +13,11 @@ import { ConditionVariable } from '../utils/ConditionVariable';
 import { getLogger } from '../utils/logger';
 import { Timer } from '../utils/Timer';
 import {
-  IContentAssistEntry,
-  isContentAssistResult,
-  isDocumentStateResult,
-  isInvalidStateIdConflictResult,
+  ContentAssistEntry,
+  contentAssistResult,
+  documentStateResult,
+  formattingResult,
+  isConflictResult,
 } from './xtextServiceResults';
 
 const UPDATE_TIMEOUT_MS = 500;
@@ -23,6 +26,8 @@ const WAIT_FOR_UPDATE_TIMEOUT_MS = 1000;
 
 const log = getLogger('xtext.UpdateService');
 
+const setDirtyChanges = StateEffect.define<ChangeSet>();
+
 export interface IAbortSignal {
   aborted: boolean;
 }
@@ -38,12 +43,12 @@ export class UpdateService {
    * The changes being synchronized to the server if a full or delta text update is running,
    * `null` otherwise.
    */
-  private pendingUpdate: ChangeDesc | null = null;
+  private pendingUpdate: ChangeSet | null = null;
 
   /**
    * Local changes not yet sychronized to the server and not part of the running update, if any.
    */
-  private dirtyChanges: ChangeDesc;
+  private dirtyChanges: ChangeSet;
 
   private readonly webSocketClient: XtextWebSocketClient;
 
@@ -59,7 +64,7 @@ export class UpdateService {
   constructor(store: EditorStore, webSocketClient: XtextWebSocketClient) {
     this.resourceName = `${nanoid(7)}.problem`;
     this.store = store;
-    this.dirtyChanges = this.newEmptyChangeDesc();
+    this.dirtyChanges = this.newEmptyChangeSet();
     this.webSocketClient = webSocketClient;
   }
 
@@ -71,8 +76,19 @@ export class UpdateService {
   }
 
   onTransaction(transaction: Transaction): void {
+    const setDirtyChangesEffect = transaction.effects.find(
+      (effect) => effect.is(setDirtyChanges),
+    ) as StateEffect<ChangeSet> | undefined;
+    if (setDirtyChangesEffect) {
+      const { value } = setDirtyChangesEffect;
+      if (this.pendingUpdate !== null) {
+        this.pendingUpdate = ChangeSet.empty(value.length);
+      }
+      this.dirtyChanges = value;
+      return;
+    }
     if (transaction.docChanged) {
-      this.dirtyChanges = this.dirtyChanges.composeDesc(transaction.changes.desc);
+      this.dirtyChanges = this.dirtyChanges.compose(transaction.changes);
       this.idleUpdateTimer.reschedule();
     }
   }
@@ -86,7 +102,7 @@ export class UpdateService {
    * @return the summary of changes since the last update
    */
   computeChangesSinceLastUpdate(): ChangeDesc {
-    return this.pendingUpdate?.composeDesc(this.dirtyChanges) || this.dirtyChanges;
+    return this.pendingUpdate?.composeDesc(this.dirtyChanges.desc) || this.dirtyChanges.desc;
   }
 
   private handleIdleUpdate() {
@@ -101,9 +117,8 @@ export class UpdateService {
     this.idleUpdateTimer.reschedule();
   }
 
-  private newEmptyChangeDesc() {
-    const changeSet = ChangeSet.of([], this.store.state.doc.length);
-    return changeSet.desc;
+  private newEmptyChangeSet() {
+    return ChangeSet.of([], this.store.state.doc.length);
   }
 
   async updateFullText(): Promise<void> {
@@ -116,11 +131,8 @@ export class UpdateService {
       serviceType: 'update',
       fullText: this.store.state.doc.sliceString(0),
     });
-    if (isDocumentStateResult(result)) {
-      return [result.stateId, undefined];
-    }
-    log.error('Unexpected full text update result:', result);
-    throw new Error('Full text update failed');
+    const { stateId } = documentStateResult.parse(result);
+    return [stateId, undefined];
   }
 
   /**
@@ -146,14 +158,14 @@ export class UpdateService {
         requiredStateId: this.xtextStateId,
         ...delta,
       });
-      if (isDocumentStateResult(result)) {
-        return [result.stateId, undefined];
+      const parsedDocumentStateResult = documentStateResult.safeParse(result);
+      if (parsedDocumentStateResult.success) {
+        return [parsedDocumentStateResult.data.stateId, undefined];
       }
-      if (isInvalidStateIdConflictResult(result)) {
+      if (isConflictResult(result, 'invalidStateId')) {
         return this.doFallbackToUpdateFullText();
       }
-      log.error('Unexpected delta text update result:', result);
-      throw new Error('Delta text update failed');
+      throw parsedDocumentStateResult.error;
     });
   }
 
@@ -163,15 +175,15 @@ export class UpdateService {
     }
     log.warn('Delta update failed, performing full text update');
     this.xtextStateId = null;
-    this.pendingUpdate = this.pendingUpdate.composeDesc(this.dirtyChanges);
-    this.dirtyChanges = this.newEmptyChangeDesc();
+    this.pendingUpdate = this.pendingUpdate.compose(this.dirtyChanges);
+    this.dirtyChanges = this.newEmptyChangeSet();
     return this.doUpdateFullText();
   }
 
   async fetchContentAssist(
     params: Record<string, unknown>,
     signal: IAbortSignal,
-  ): Promise<IContentAssistEntry[]> {
+  ): Promise<ContentAssistEntry[]> {
     await this.prepareForDeltaUpdate();
     if (signal.aborted) {
       return [];
@@ -185,18 +197,20 @@ export class UpdateService {
           requiredStateId: this.xtextStateId,
           ...delta,
         });
-        if (isContentAssistResult(result)) {
-          return [result.stateId, result.entries];
+        const parsedContentAssistResult = contentAssistResult.safeParse(result);
+        if (parsedContentAssistResult.success) {
+          const { stateId, entries: resultEntries } = parsedContentAssistResult.data;
+          return [stateId, resultEntries];
         }
-        if (isInvalidStateIdConflictResult(result)) {
+        if (isConflictResult(result, 'invalidStateId')) {
+          log.warn('Server state invalid during content assist');
           const [newStateId] = await this.doFallbackToUpdateFullText();
           // We must finish this state update transaction to prepare for any push events
           // before querying for content assist, so we just return `null` and will query
           // the content assist service later.
           return [newStateId, null];
         }
-        log.error('Unextpected content assist result with delta update', result);
-        throw new Error('Unexpexted content assist result with delta update');
+        throw parsedContentAssistResult.error;
       });
       if (entries !== null) {
         return entries;
@@ -214,11 +228,36 @@ export class UpdateService {
       ...params,
       requiredStateId: expectedStateId,
     });
-    if (isContentAssistResult(result) && result.stateId === expectedStateId) {
-      return result.entries;
+    const { stateId, entries } = contentAssistResult.parse(result);
+    if (stateId !== expectedStateId) {
+      throw new Error(`Unexpected state id, expected: ${expectedStateId} got: ${stateId}`);
     }
-    log.error('Unexpected content assist result', result);
-    throw new Error('Unexpected content assist result');
+    return entries;
+  }
+
+  async formatText(): Promise<void> {
+    await this.update();
+    let { from, to } = this.store.state.selection.main;
+    if (to <= from) {
+      from = 0;
+      to = this.store.state.doc.length;
+    }
+    log.debug('Formatting from', from, 'to', to);
+    await this.withUpdate(async () => {
+      const result = await this.webSocketClient.send({
+        resource: this.resourceName,
+        serviceType: 'format',
+        selectionStart: from,
+        selectionEnd: to,
+      });
+      const { stateId, formattedText } = formattingResult.parse(result);
+      this.applyBeforeDirtyChanges({
+        from,
+        to,
+        insert: formattedText,
+      });
+      return [stateId, null];
+    });
   }
 
   private computeDelta() {
@@ -242,6 +281,20 @@ export class UpdateService {
     };
   }
 
+  private applyBeforeDirtyChanges(changeSpec: ChangeSpec) {
+    const pendingChanges = this.pendingUpdate?.compose(this.dirtyChanges) || this.dirtyChanges;
+    const revertChanges = pendingChanges.invert(this.store.state.doc);
+    const applyBefore = ChangeSet.of(changeSpec, revertChanges.newLength);
+    const redoChanges = pendingChanges.map(applyBefore.desc);
+    const changeSet = revertChanges.compose(applyBefore).compose(redoChanges);
+    this.store.dispatch({
+      changes: changeSet,
+      effects: [
+        setDirtyChanges.of(redoChanges),
+      ],
+    });
+  }
+
   /**
    * Executes an asynchronous callback that updates the state on the server.
    *
@@ -268,7 +321,7 @@ export class UpdateService {
       throw new Error('Another update is pending, will not perform update');
     }
     this.pendingUpdate = this.dirtyChanges;
-    this.dirtyChanges = this.newEmptyChangeDesc();
+    this.dirtyChanges = this.newEmptyChangeSet();
     let newStateId: string | null = null;
     try {
       let result: T;
@@ -282,7 +335,7 @@ export class UpdateService {
       if (this.pendingUpdate === null) {
         log.error('pendingUpdate was cleared during update');
       } else {
-        this.dirtyChanges = this.pendingUpdate.composeDesc(this.dirtyChanges);
+        this.dirtyChanges = this.pendingUpdate.compose(this.dirtyChanges);
       }
       this.pendingUpdate = null;
       this.webSocketClient.forceReconnectOnError();
diff --git a/language-web/src/main/js/xtext/ValidationService.ts b/language-web/src/main/js/xtext/ValidationService.ts
index 8e4934ac..c7f6ac7f 100644
--- a/language-web/src/main/js/xtext/ValidationService.ts
+++ b/language-web/src/main/js/xtext/ValidationService.ts
@@ -3,9 +3,7 @@ import type { Diagnostic } from '@codemirror/lint';
 import type { EditorStore } from '../editor/EditorStore';
 import type { UpdateService } from './UpdateService';
 import { getLogger } from '../utils/logger';
-import { isValidationResult } from './xtextServiceResults';
-
-const log = getLogger('xtext.ValidationService');
+import { validationResult } from './xtextServiceResults';
 
 export class ValidationService {
   private readonly store: EditorStore;
@@ -18,13 +16,10 @@ export class ValidationService {
   }
 
   onPush(push: unknown): void {
-    if (!isValidationResult(push)) {
-      log.error('Invalid validation result', push);
-      return;
-    }
+    const { issues } = validationResult.parse(push);
     const allChanges = this.updateService.computeChangesSinceLastUpdate();
     const diagnostics: Diagnostic[] = [];
-    push.issues.forEach(({
+    issues.forEach(({
       offset,
       length,
       severity,
diff --git a/language-web/src/main/js/xtext/XtextClient.ts b/language-web/src/main/js/xtext/XtextClient.ts
index 28f3d0cc..0898e725 100644
--- a/language-web/src/main/js/xtext/XtextClient.ts
+++ b/language-web/src/main/js/xtext/XtextClient.ts
@@ -12,6 +12,7 @@ import { UpdateService } from './UpdateService';
 import { getLogger } from '../utils/logger';
 import { ValidationService } from './ValidationService';
 import { XtextWebSocketClient } from './XtextWebSocketClient';
+import { XtextWebPushService } from './xtextMessages';
 
 const log = getLogger('xtext.XtextClient');
 
@@ -52,7 +53,7 @@ export class XtextClient {
     this.occurrencesService.onTransaction(transaction);
   }
 
-  private onPush(resource: string, stateId: string, service: string, push: unknown) {
+  private onPush(resource: string, stateId: string, service: XtextWebPushService, push: unknown) {
     const { resourceName, xtextStateId } = this.updateService;
     if (resource !== resourceName) {
       log.error('Unknown resource name: expected:', resourceName, 'got:', resource);
@@ -70,14 +71,16 @@ export class XtextClient {
         return;
       case 'validate':
         this.validationService.onPush(push);
-        return;
-      default:
-        log.error('Unknown push service:', service);
-        break;
     }
   }
 
   contentAssist(context: CompletionContext): Promise<CompletionResult> {
     return this.contentAssistService.contentAssist(context);
   }
+
+  formatText(): void {
+    this.updateService.formatText().catch((e) => {
+      log.error('Error while formatting text', e);
+    });
+  }
 }
diff --git a/language-web/src/main/js/xtext/XtextWebSocketClient.ts b/language-web/src/main/js/xtext/XtextWebSocketClient.ts
index 488e4b3b..2ce20a54 100644
--- a/language-web/src/main/js/xtext/XtextWebSocketClient.ts
+++ b/language-web/src/main/js/xtext/XtextWebSocketClient.ts
@@ -4,12 +4,13 @@ import { getLogger } from '../utils/logger';
 import { PendingTask } from '../utils/PendingTask';
 import { Timer } from '../utils/Timer';
 import {
-  isErrorResponse,
-  isOkResponse,
-  isPushMessage,
-  IXtextWebRequest,
+  xtextWebErrorResponse,
+  XtextWebRequest,
+  xtextWebOkResponse,
+  xtextWebPushMessage,
+  XtextWebPushService,
 } from './xtextMessages';
-import { isPongResult } from './xtextServiceResults';
+import { pongResult } from './xtextServiceResults';
 
 const XTEXT_SUBPROTOCOL_V1 = 'tools.refinery.language.web.xtext.v1';
 
@@ -32,7 +33,7 @@ export type ReconnectHandler = () => void;
 export type PushHandler = (
   resourceId: string,
   stateId: string,
-  service: string,
+  service: XtextWebPushService,
   data: unknown,
 ) => void;
 
@@ -192,11 +193,12 @@ export class XtextWebSocketClient {
     const ping = nanoid();
     log.trace('Ping', ping);
     this.send({ ping }).then((result) => {
-      if (isPongResult(result) && result.pong === ping) {
+      const parsedPongResult = pongResult.safeParse(result);
+      if (parsedPongResult.success && parsedPongResult.data.pong === ping) {
         log.trace('Pong', ping);
         this.pingTimer.schedule();
       } else {
-        log.error('Invalid pong');
+        log.error('Invalid pong:', parsedPongResult, 'expected:', ping);
         this.forceReconnectOnError();
       }
     }).catch((error) => {
@@ -222,7 +224,7 @@ export class XtextWebSocketClient {
     const message = JSON.stringify({
       id: messageId,
       request,
-    } as IXtextWebRequest);
+    } as XtextWebRequest);
     log.trace('Sending message', message);
     return new Promise((resolve, reject) => {
       const task = new PendingTask(resolve, reject, REQUEST_TIMEOUT_MS, () => {
@@ -248,23 +250,42 @@ export class XtextWebSocketClient {
       this.forceReconnectOnError();
       return;
     }
-    if (isOkResponse(message)) {
-      this.resolveRequest(message.id, message.response);
-    } else if (isErrorResponse(message)) {
-      this.rejectRequest(message.id, new Error(`${message.error} error: ${message.message}`));
-      if (message.error === 'server') {
-        log.error('Reconnecting due to server error: ', message.message);
+    const okResponse = xtextWebOkResponse.safeParse(message);
+    if (okResponse.success) {
+      const { id, response } = okResponse.data;
+      this.resolveRequest(id, response);
+      return;
+    }
+    const errorResponse = xtextWebErrorResponse.safeParse(message);
+    if (errorResponse.success) {
+      const { id, error, message: errorMessage } = errorResponse.data;
+      this.rejectRequest(id, new Error(`${error} error: ${errorMessage}`));
+      if (error === 'server') {
+        log.error('Reconnecting due to server error: ', errorMessage);
         this.forceReconnectOnError();
       }
-    } else if (isPushMessage(message)) {
-      this.onPush(
-        message.resource,
-        message.stateId,
-        message.service,
-        message.push,
-      );
+      return;
+    }
+    const pushMessage = xtextWebPushMessage.safeParse(message);
+    if (pushMessage.success) {
+      const {
+        resource,
+        stateId,
+        service,
+        push,
+      } = pushMessage.data;
+      this.onPush(resource, stateId, service, push);
     } else {
-      log.error('Unexpected websocket message', message);
+      log.error(
+        'Unexpected websocket message:',
+        message,
+        'not ok response because:',
+        okResponse.error,
+        'not error response because:',
+        errorResponse.error,
+        'not push message because:',
+        pushMessage.error,
+      );
       this.forceReconnectOnError();
     }
   }
diff --git a/language-web/src/main/js/xtext/xtextMessages.ts b/language-web/src/main/js/xtext/xtextMessages.ts
index 68737958..c4305fcf 100644
--- a/language-web/src/main/js/xtext/xtextMessages.ts
+++ b/language-web/src/main/js/xtext/xtextMessages.ts
@@ -1,62 +1,40 @@
-export interface IXtextWebRequest {
-  id: string;
+import { z } from 'zod';
 
-  request: unknown;
-}
+export const xtextWebRequest = z.object({
+  id: z.string().nonempty(),
+  request: z.unknown(),
+});
 
-export interface IXtextWebOkResponse {
-  id: string;
+export type XtextWebRequest = z.infer<typeof xtextWebRequest>;
 
-  response: unknown;
-}
+export const xtextWebOkResponse = z.object({
+  id: z.string().nonempty(),
+  response: z.unknown(),
+});
 
-export function isOkResponse(response: unknown): response is IXtextWebOkResponse {
-  const okResponse = response as IXtextWebOkResponse;
-  return typeof okResponse === 'object'
-    && typeof okResponse.id === 'string'
-    && typeof okResponse.response !== 'undefined';
-}
+export type XtextWebOkResponse = z.infer<typeof xtextWebOkResponse>;
 
-export const VALID_XTEXT_WEB_ERROR_KINDS = ['request', 'server'] as const;
+export const xtextWebErrorKind = z.enum(['request', 'server']);
 
-export type XtextWebErrorKind = typeof VALID_XTEXT_WEB_ERROR_KINDS[number];
+export type XtextWebErrorKind = z.infer<typeof xtextWebErrorKind>;
 
-export function isXtextWebErrorKind(value: unknown): value is XtextWebErrorKind {
-  return typeof value === 'string'
-    && VALID_XTEXT_WEB_ERROR_KINDS.includes(value as XtextWebErrorKind);
-}
+export const xtextWebErrorResponse = z.object({
+  id: z.string().nonempty(),
+  error: xtextWebErrorKind,
+  message: z.string(),
+});
 
-export interface IXtextWebErrorResponse {
-  id: string;
+export type XtextWebErrorResponse = z.infer<typeof xtextWebErrorResponse>;
 
-  error: XtextWebErrorKind;
+export const xtextWebPushService = z.enum(['highlight', 'validate']);
 
-  message: string;
-}
+export type XtextWebPushService = z.infer<typeof xtextWebPushService>;
 
-export function isErrorResponse(response: unknown): response is IXtextWebErrorResponse {
-  const errorResponse = response as IXtextWebErrorResponse;
-  return typeof errorResponse === 'object'
-    && typeof errorResponse.id === 'string'
-    && isXtextWebErrorKind(errorResponse.error)
-    && typeof errorResponse.message === 'string';
-}
+export const xtextWebPushMessage = z.object({
+  resource: z.string().nonempty(),
+  stateId: z.string().nonempty(),
+  service: xtextWebPushService,
+  push: z.unknown(),
+});
 
-export interface IXtextWebPushMessage {
-  resource: string;
-
-  stateId: string;
-
-  service: string;
-
-  push: unknown;
-}
-
-export function isPushMessage(response: unknown): response is IXtextWebPushMessage {
-  const pushMessage = response as IXtextWebPushMessage;
-  return typeof pushMessage === 'object'
-    && typeof pushMessage.resource === 'string'
-    && typeof pushMessage.stateId === 'string'
-    && typeof pushMessage.service === 'string'
-    && typeof pushMessage.push !== 'undefined';
-}
+export type XtextWebPushMessage = z.infer<typeof xtextWebPushMessage>;
diff --git a/language-web/src/main/js/xtext/xtextServiceResults.ts b/language-web/src/main/js/xtext/xtextServiceResults.ts
index b2de1e4a..f79b059c 100644
--- a/language-web/src/main/js/xtext/xtextServiceResults.ts
+++ b/language-web/src/main/js/xtext/xtextServiceResults.ts
@@ -1,239 +1,112 @@
-export interface IPongResult {
-  pong: string;
-}
-
-export function isPongResult(result: unknown): result is IPongResult {
-  const pongResult = result as IPongResult;
-  return typeof pongResult === 'object'
-    && typeof pongResult.pong === 'string';
-}
-
-export interface IDocumentStateResult {
-  stateId: string;
-}
-
-export function isDocumentStateResult(result: unknown): result is IDocumentStateResult {
-  const documentStateResult = result as IDocumentStateResult;
-  return typeof documentStateResult === 'object'
-    && typeof documentStateResult.stateId === 'string';
-}
-
-export const VALID_CONFLICTS = ['invalidStateId', 'canceled'] as const;
-
-export type Conflict = typeof VALID_CONFLICTS[number];
-
-export function isConflict(value: unknown): value is Conflict {
-  return typeof value === 'string' && VALID_CONFLICTS.includes(value as Conflict);
-}
-
-export interface IServiceConflictResult {
-  conflict: Conflict;
-}
-
-export function isServiceConflictResult(result: unknown): result is IServiceConflictResult {
-  const serviceConflictResult = result as IServiceConflictResult;
-  return typeof serviceConflictResult === 'object'
-    && isConflict(serviceConflictResult.conflict);
-}
-
-export function isInvalidStateIdConflictResult(result: unknown): boolean {
-  return isServiceConflictResult(result) && result.conflict === 'invalidStateId';
-}
-
-export const VALID_SEVERITIES = ['error', 'warning', 'info', 'ignore'] as const;
-
-export type Severity = typeof VALID_SEVERITIES[number];
-
-export function isSeverity(value: unknown): value is Severity {
-  return typeof value === 'string' && VALID_SEVERITIES.includes(value as Severity);
-}
-
-export interface IIssue {
-  description: string;
-
-  severity: Severity;
-
-  line: number;
-
-  column: number;
-
-  offset: number;
+import { z } from 'zod';
 
-  length: number;
-}
+export const pongResult = z.object({
+  pong: z.string().nonempty(),
+});
 
-export function isIssue(value: unknown): value is IIssue {
-  const issue = value as IIssue;
-  return typeof issue === 'object'
-    && typeof issue.description === 'string'
-    && isSeverity(issue.severity)
-    && typeof issue.line === 'number'
-    && typeof issue.column === 'number'
-    && typeof issue.offset === 'number'
-    && typeof issue.length === 'number';
-}
+export type PongResult = z.infer<typeof pongResult>;
 
-export interface IValidationResult {
-  issues: IIssue[];
-}
+export const documentStateResult = z.object({
+  stateId: z.string().nonempty(),
+});
 
-function isArrayOfType<T>(value: unknown, check: (entry: unknown) => entry is T): value is T[] {
-  return Array.isArray(value) && (value as T[]).every(check);
-}
+export type DocumentStateResult = z.infer<typeof documentStateResult>;
 
-export function isValidationResult(result: unknown): result is IValidationResult {
-  const validationResult = result as IValidationResult;
-  return typeof validationResult === 'object'
-    && isArrayOfType(validationResult.issues, isIssue);
-}
-
-export interface IReplaceRegion {
-  offset: number;
+export const conflict = z.enum(['invalidStateId', 'canceled']);
 
-  length: number;
+export type Conflict = z.infer<typeof conflict>;
 
-  text: string;
-}
+export const serviceConflictResult = z.object({
+  conflict,
+});
 
-export function isReplaceRegion(value: unknown): value is IReplaceRegion {
-  const replaceRegion = value as IReplaceRegion;
-  return typeof replaceRegion === 'object'
-    && typeof replaceRegion.offset === 'number'
-    && typeof replaceRegion.length === 'number'
-    && typeof replaceRegion.text === 'string';
-}
-
-export interface ITextRegion {
-  offset: number;
-
-  length: number;
-}
-
-export function isTextRegion(value: unknown): value is ITextRegion {
-  const textRegion = value as ITextRegion;
-  return typeof textRegion === 'object'
-    && typeof textRegion.offset === 'number'
-    && typeof textRegion.length === 'number';
-}
+export type ServiceConflictResult = z.infer<typeof serviceConflictResult>;
 
-export const VALID_XTEXT_CONTENT_ASSIST_ENTRY_KINDS = [
-  'TEXT',
-  'METHOD',
-  'FUNCTION',
-  'CONSTRUCTOR',
-  'FIELD',
-  'VARIABLE',
-  'CLASS',
-  'INTERFACE',
-  'MODULE',
-  'PROPERTY',
-  'UNIT',
-  'VALUE',
-  'ENUM',
-  'KEYWORD',
-  'SNIPPET',
-  'COLOR',
-  'FILE',
-  'REFERENCE',
-  'UNKNOWN',
-] as const;
-
-export type XtextContentAssistEntryKind = typeof VALID_XTEXT_CONTENT_ASSIST_ENTRY_KINDS[number];
-
-export function isXtextContentAssistEntryKind(
-  value: unknown,
-): value is XtextContentAssistEntryKind {
-  return typeof value === 'string'
-    && VALID_XTEXT_CONTENT_ASSIST_ENTRY_KINDS.includes(value as XtextContentAssistEntryKind);
+export function isConflictResult(result: unknown, conflictType: Conflict): boolean {
+  const parsedConflictResult = serviceConflictResult.safeParse(result);
+  return parsedConflictResult.success && parsedConflictResult.data.conflict === conflictType;
 }
 
-export interface IContentAssistEntry {
-  prefix: string;
+export const severity = z.enum(['error', 'warning', 'info', 'ignore']);
 
-  proposal: string;
+export type Severity = z.infer<typeof severity>;
 
-  label?: string;
+export const issue = z.object({
+  description: z.string().nonempty(),
+  severity,
+  line: z.number().int(),
+  column: z.number().int().nonnegative(),
+  offset: z.number().int().nonnegative(),
+  length: z.number().int().nonnegative(),
+});
 
-  description?: string;
+export type Issue = z.infer<typeof issue>;
 
-  documentation?: string;
+export const validationResult = z.object({
+  issues: issue.array(),
+});
 
-  escapePosition?: number;
+export type ValidationResult = z.infer<typeof validationResult>;
 
-  textReplacements: IReplaceRegion[];
+export const replaceRegion = z.object({
+  offset: z.number().int().nonnegative(),
+  length: z.number().int().nonnegative(),
+  text: z.string(),
+});
 
-  editPositions: ITextRegion[];
+export type ReplaceRegion = z.infer<typeof replaceRegion>;
 
-  kind: XtextContentAssistEntryKind | string;
-}
+export const textRegion = z.object({
+  offset: z.number().int().nonnegative(),
+  length: z.number().int().nonnegative(),
+});
 
-function isStringOrUndefined(value: unknown): value is string | undefined {
-  return typeof value === 'string' || typeof value === 'undefined';
-}
+export type TextRegion = z.infer<typeof textRegion>;
 
-function isNumberOrUndefined(value: unknown): value is number | undefined {
-  return typeof value === 'number' || typeof value === 'undefined';
-}
+export const contentAssistEntry = z.object({
+  prefix: z.string(),
+  proposal: z.string().nonempty(),
+  label: z.string().optional(),
+  description: z.string().nonempty().optional(),
+  documentation: z.string().nonempty().optional(),
+  escapePosition: z.number().int().nonnegative().optional(),
+  textReplacements: replaceRegion.array(),
+  editPositions: textRegion.array(),
+  kind: z.string().nonempty(),
+});
 
-export function isContentAssistEntry(value: unknown): value is IContentAssistEntry {
-  const entry = value as IContentAssistEntry;
-  return typeof entry === 'object'
-    && typeof entry.prefix === 'string'
-    && typeof entry.proposal === 'string'
-    && isStringOrUndefined(entry.label)
-    && isStringOrUndefined(entry.description)
-    && isStringOrUndefined(entry.documentation)
-    && isNumberOrUndefined(entry.escapePosition)
-    && isArrayOfType(entry.textReplacements, isReplaceRegion)
-    && isArrayOfType(entry.editPositions, isTextRegion)
-    && typeof entry.kind === 'string';
-}
+export type ContentAssistEntry = z.infer<typeof contentAssistEntry>;
 
-export interface IContentAssistResult extends IDocumentStateResult {
-  entries: IContentAssistEntry[];
-}
+export const contentAssistResult = documentStateResult.extend({
+  entries: contentAssistEntry.array(),
+});
 
-export function isContentAssistResult(result: unknown): result is IContentAssistResult {
-  const contentAssistResult = result as IContentAssistResult;
-  return isDocumentStateResult(result)
-    && isArrayOfType(contentAssistResult.entries, isContentAssistEntry);
-}
+export type ContentAssistResult = z.infer<typeof contentAssistResult>;
 
-export interface IHighlightingRegion {
-  offset: number;
+export const highlightingRegion = z.object({
+  offset: z.number().int().nonnegative(),
+  length: z.number().int().nonnegative(),
+  styleClasses: z.string().nonempty().array(),
+});
 
-  length: number;
+export type HighlightingRegion = z.infer<typeof highlightingRegion>;
 
-  styleClasses: string[];
-}
+export const highlightingResult = z.object({
+  regions: highlightingRegion.array(),
+});
 
-export function isHighlightingRegion(value: unknown): value is IHighlightingRegion {
-  const region = value as IHighlightingRegion;
-  return typeof region === 'object'
-    && typeof region.offset === 'number'
-    && typeof region.length === 'number'
-    && isArrayOfType(region.styleClasses, (s): s is string => typeof s === 'string');
-}
-
-export interface IHighlightingResult {
-  regions: IHighlightingRegion[];
-}
+export type HighlightingResult = z.infer<typeof highlightingResult>;
 
-export function isHighlightingResult(result: unknown): result is IHighlightingResult {
-  const highlightingResult = result as IHighlightingResult;
-  return typeof highlightingResult === 'object'
-    && isArrayOfType(highlightingResult.regions, isHighlightingRegion);
-}
+export const occurrencesResult = documentStateResult.extend({
+  writeRegions: textRegion.array(),
+  readRegions: textRegion.array(),
+});
 
-export interface IOccurrencesResult extends IDocumentStateResult {
-  writeRegions: ITextRegion[];
+export type OccurrencesResult = z.infer<typeof occurrencesResult>;
 
-  readRegions: ITextRegion[];
-}
+export const formattingResult = documentStateResult.extend({
+  formattedText: z.string(),
+  replaceRegion: textRegion,
+});
 
-export function isOccurrencesResult(result: unknown): result is IOccurrencesResult {
-  const occurrencesResult = result as IOccurrencesResult;
-  return isDocumentStateResult(occurrencesResult)
-    && isArrayOfType(occurrencesResult.writeRegions, isTextRegion)
-    && isArrayOfType(occurrencesResult.readRegions, isTextRegion);
-}
+export type FormattingResult = z.infer<typeof formattingResult>;