@geode/opengeodeweb-front 10.39.0-rc.1 → 10.40.0-rc.1

package/.build/server/utils/cleanup.js

@@ -1,8 +1,8 @@
+import { createServerWsRpcClient } from "./ws_client.js";
 import path from "node:path";
 import { consola } from "consola";
 import fs from "node:fs";
 import { setTimeout } from "node:timers/promises";
-import { WebSocket } from "ws";
 import pTimeout from "p-timeout";
 import { rimraf } from "rimraf";
 //#region server/utils/cleanup.ts
@@ -51,40 +51,19 @@ async function killWebsocketMicroservice(microservice) {
 	const successMessage = `Disconnected from ${microservice.name} WebSocket server`;
 	async function do_kill() {
 		if (microservice.url === void 0) return;
-		const socketUrl = microservice.url;
-		await new Promise((resolve) => {
-			const socket = new WebSocket(socketUrl);
-			socket.on("open", () => {
-				consola.info("Connected to WebSocket server");
-				socket.send(JSON.stringify({
-					id: "system:hello",
-					method: "wslink.hello",
-					args: [{ secret: "wslink-secret" }]
-				}));
-			});
-			socket.on("message", (data) => {
-				const message = data.toString();
-				consola.debug("Received from server:", message);
-				if (message.includes("hello")) {
-					socket.send(JSON.stringify({
-						id: "application.exit",
-						method: "application.exit"
-					}));
-					consola.info(successMessage);
-					socket.close();
-					resolve();
-				}
-			});
-			socket.on("close", () => {
-				consola.info(successMessage);
-				resolve();
-			});
-			socket.on("error", (error) => {
-				consola.error("WebSocket error:", error);
-				socket.close();
-				resolve();
-			});
+		const client = createServerWsRpcClient(microservice.url);
+		const closed = new Promise((resolve) => {
+			client.onConnectionClose(resolve);
 		});
+		try {
+			await client.notify("application.exit");
+			await closed;
+			consola.info(successMessage);
+		} catch (error) {
+			consola.error("WebSocket error:", error);
+		} finally {
+			client.close();
+		}
 	}
 	await pTimeout(do_kill(), {
 		milliseconds: 5e3,

package/.build/server/utils/path.js

@@ -4,8 +4,8 @@ import path from "node:path";
 import { consola } from "consola";
 import fs from "node:fs";
 import { setTimeout } from "node:timers/promises";
-import os from "node:os";
 import { v4 } from "uuid";
+import os from "node:os";
 //#region server/utils/path.ts
 function executableName(execName) {
 	if (process.platform === "win32") return `${execName}.exe`;

package/.build/server/utils/ws_client.js

@@ -1,39 +1,47 @@
+import { Decoder, encode } from "@msgpack/msgpack";
+import { UnChunker, generateChunks } from "wslink/src/WebsocketConnection/chunking.js";
 import { WebSocket } from "ws";
 import { v4 } from "uuid";
 //#region server/utils/ws_client.ts
 const HELLO_ID = "system:hello";
 const HELLO_SECRET = "wslink-secret";
+const DEFAULT_MAX_MSG_SIZE = 524288;
 function isWsRpcMessage(value) {
 	return typeof value === "object" && value !== null;
 }
-function rawDataToString(raw) {
-	if (Buffer.isBuffer(raw)) return raw.toString();
-	if (Array.isArray(raw)) return Buffer.concat(raw).toString();
-	return Buffer.from(raw).toString();
+function rawDataToBlob(raw) {
+	if (raw instanceof ArrayBuffer) return new Blob([raw]);
+	return new Blob([Uint8Array.from(Array.isArray(raw) ? Buffer.concat(raw) : raw)]);
 }
 function createServerWsRpcClient(baseUrl) {
 	const socket = new WebSocket(baseUrl);
 	const pending = /* @__PURE__ */ new Map();
+	const unChunker = new UnChunker();
+	let maxMsgSize = DEFAULT_MAX_MSG_SIZE;
 	let onCloseCallback = void 0;
 	let onErrorCallback = void 0;
+	function send(message) {
+		for (const chunk of generateChunks(encode(message), maxMsgSize)) socket.send(chunk);
+	}
 	const ready = new Promise((resolve, reject) => {
 		socket.on("open", () => {
-			socket.send(JSON.stringify({
+			send({
 				id: HELLO_ID,
 				method: "wslink.hello",
 				args: [{ secret: HELLO_SECRET }]
-			}));
+			});
 		});
-		socket.on("message", (raw) => {
+		async function handleMessage(raw) {
 			let message = void 0;
 			try {
-				const parsed = JSON.parse(rawDataToString(raw));
-				if (!isWsRpcMessage(parsed)) return;
-				message = parsed;
+				const decoded = await unChunker.processChunk(rawDataToBlob(raw), () => new Decoder());
+				if (!isWsRpcMessage(decoded)) return;
+				message = decoded;
 			} catch {
 				return;
 			}
 			if (message.id === HELLO_ID) {
+				maxMsgSize = message.result?.maxMsgSize ?? maxMsgSize;
 				resolve();
 				return;
 			}
@@ -43,12 +51,16 @@ function createServerWsRpcClient(baseUrl) {
 			pending.delete(message.id);
 			if (message.error) entry.reject(new Error(message.error.message ?? "wslink RPC error"));
 			else entry.resolve(message.result);
+		}
+		socket.on("message", (raw) => {
+			handleMessage(raw);
 		});
 		socket.on("error", (error) => {
 			onErrorCallback?.(error);
 			reject(error);
 		});
 		socket.on("close", () => {
+			reject(/* @__PURE__ */ new Error("WebSocket closed"));
 			onCloseCallback?.();
 			for (const { reject: rejectPending } of pending.values()) rejectPending(/* @__PURE__ */ new Error("WebSocket closed"));
 			pending.clear();
@@ -62,13 +74,19 @@ function createServerWsRpcClient(baseUrl) {
 				resolve,
 				reject
 			});
-			socket.send(JSON.stringify({
-				wslink: "1.0",
+			send({
 				id,
 				method: rpc,
 				args: [params],
 				kwargs: { stream: true }
-			}));
+			});
+		});
+	}
+	async function notify(method) {
+		await ready;
+		send({
+			id: method,
+			method
 		});
 	}
 	function close() {
@@ -93,6 +111,7 @@ function createServerWsRpcClient(baseUrl) {
 		close,
 		getConnection,
 		isOpen,
+		notify,
 		onConnectionClose,
 		onConnectionError,
 		ready

package/.build/server/utils/wslink_chunking.d.js

@@ -0,0 +1 @@
+export {};

package/.build/shared/utils/call_raw.js

@@ -1,9 +1,21 @@
 import pTimeout from "p-timeout";
-import "lodash";
+import _ from "lodash";
 //#region shared/utils/call_raw.ts
+function isPlainRecord(value) {
+	return _.isPlainObject(value);
+}
+function omitUndefinedFields(record) {
+	function omitUndefined(value) {
+		if (Array.isArray(value)) return value.map((item) => omitUndefined(item));
+		if (isPlainRecord(value)) return omitUndefinedFields(value);
+		return value;
+	}
+	return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0).map(([key, value]) => [key, omitUndefined(value)]));
+}
 async function callClient({ rpc, params = {}, client }) {
-	if (globalThis.window !== void 0) return await client.getConnection().getSession().call(rpc, [params]);
-	return await client.call(rpc, params);
+	const definedParams = omitUndefinedFields(params);
+	if (globalThis.window !== void 0) return await client.getConnection().getSession().call(rpc, [definedParams]);
+	return await client.call(rpc, definedParams);
 }
 async function callRaw({ rpc, params = {}, client, timeout }, { request_error_function, response_function, response_error_function } = {}) {
 	async function performCall() {

package/app/components/Screenshot.vue

@@ -44,7 +44,7 @@ async function takeScreenshot(): Promise<void> {
       params,
     },
     {
-      // `blob` is a wslink attachment: the viewer sends its key, the client receives the binary in its place
+      // `blob` is the image file content, received as binary (Uint8Array) through wslink
       response_function: async ({ blob }) => {
         if (screenshot_type.value === "file") {
           fileDownload(blob, `${current_filename}.${output_extension.value}`);

package/app/composables/clipping_planes_widget_entries.ts

@@ -47,6 +47,11 @@ function asWidgetFactory(widget: PlaneWidget): vtkAbstractWidgetFactory<vtkAbstr
   return widget as unknown as vtkAbstractWidgetFactory<vtkAbstractWidget>;
 }
 
+function asWidgetHandle(widget: unknown): WidgetHandle {
+  // oxlint-disable-next-line no-unsafe-type-assertion -- vtk.js WidgetManager.addWidget is untyped for our custom WidgetHandle shape; narrowed here.
+  return widget as WidgetHandle;
+}
+
 interface WidgetEntryManagerParams {
   planes: Ref<ClippingPlane[]>;
   debouncedApply: (...args: readonly unknown[]) => void;
@@ -136,10 +141,7 @@ function useWidgetEntryManager({ planes, debouncedApply }: WidgetEntryManagerPar
     if (!widgetEntries[idx]) {
       // oxlint-disable-next-line no-unsafe-call no-unsafe-type-assertion -- vtk.js has no types for ImplicitPlaneWidget's factory; narrowed here.
       const planeWidget = vtkImplicitPlaneWidget() as PlaneWidget;
-      const widgetHandle = widgetManager.addWidget(
-        asWidgetFactory(planeWidget),
-        // oxlint-disable-next-line no-unsafe-type-assertion -- vtk.js WidgetManager.addWidget is untyped for our custom WidgetHandle shape; narrowed here.
-      ) as unknown as WidgetHandle;
+      const widgetHandle = asWidgetHandle(widgetManager.addWidget(asWidgetFactory(planeWidget)));
       widgetEntries.push(createWidgetEntry(planeWidget, widgetHandle, idx));
     }
     const entry = widgetEntries[idx];

package/app/stores/camera_manager.ts

@@ -1,10 +1,10 @@
-import { type Table, liveQuery } from "dexie";
-import type { Observable } from "rxjs";
+import type { Table } from "dexie";
 import { useObservable } from "@vueuse/rxjs";
 
 // Local imports
 import type { CameraOptions } from "@ogw_internal/stores/hybrid_viewer/vtk_types.js";
 import { database } from "@ogw_internal/database/database.js";
+import { liveObservable } from "@ogw_front/utils/live_observable";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
@@ -26,16 +26,11 @@ export const useCameraManagerStore = defineStore("camera_manager", () => {
   >;
 
   function refAllCameraPositions(): Ref<CameraPositionRecord[]> {
-    // Dexie's liveQuery() returns Dexie's own minimal Observable shape, not an
-    // Actual rxjs Observable instance (useObservable's declared parameter type);
-    // The two are structurally close enough at runtime (vueuse only calls
-    // `.subscribe`) but not identical, hence the cast.
     return useObservable(
-      liveQuery(async () => {
+      liveObservable(async () => {
         const positions = await camera_positions_db.toArray();
         return positions;
-        // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vueuse/Dexie Observable boundary; see comment above.
-      }) as unknown as Observable<CameraPositionRecord[]>,
+      }),
       { initialValue: [] as CameraPositionRecord[] },
     );
   }

package/app/stores/data.ts

@@ -1,13 +1,13 @@
 // oxlint-disable eslint/max-lines
 // Third party imports
-import { type Table, liveQuery } from "dexie";
-import type { Observable } from "rxjs";
+import type { Table } from "dexie";
 import { useObservable } from "@vueuse/rxjs";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
 // Local imports
 import { type ModelComponentRecord, useDataMesh } from "./data_helpers/mesh.js";
 import { database } from "@ogw_internal/database/database.js";
+import { liveObservable } from "@ogw_front/utils/live_observable";
 import { useDataCollections } from "./data_helpers/collections.js";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
@@ -137,16 +137,11 @@ export const useDataStore = defineStore("data", () => {
     return items;
   }
   function refItem(id: string): Ref<DataItem | undefined> {
-    // Dexie's liveQuery() returns Dexie's own minimal Observable shape, not an
-    // Actual rxjs Observable instance (useObservable's declared parameter type);
-    // The two are structurally close enough at runtime (vueuse only calls
-    // `.subscribe`) but not identical, hence the cast.
     return useObservable(
-      liveQuery(async () => {
+      liveObservable(async () => {
         const data_item = await data_db.get(id);
         return data_item;
-        // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vueuse/Dexie Observable boundary; see comment above.
-      }) as unknown as Observable<DataItem | undefined>,
+      }),
       {
         // oxlint-disable-next-line no-unsafe-type-assertion -- placeholder until the live query resolves; consumers must treat this as possibly incomplete.
         initialValue: {} as DataItem,
@@ -155,11 +150,10 @@ export const useDataStore = defineStore("data", () => {
   }
   function refAllItems(): Ref<DataItem[]> {
     return useObservable(
-      liveQuery(async () => {
+      liveObservable(async () => {
         const items = await data_db.toArray();
         return items;
-        // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vueuse/Dexie Observable boundary; see comment above.
-      }) as unknown as Observable<DataItem[]>,
+      }),
       {
         initialValue: [] as DataItem[],
       },

package/app/stores/data_helpers/collections.ts

@@ -1,9 +1,8 @@
 import { type FormattedComponent, type ModelComponentRecord, useDataMesh } from "./mesh.js";
 import { MESH_COMPONENT_TYPES } from "@ogw_front/utils/default_styles";
-import type { Observable } from "rxjs";
 import type { Ref } from "vue";
 import { getTable } from "@ogw_internal/database/database.js";
-import { liveQuery } from "dexie";
+import { liveObservable } from "@ogw_front/utils/live_observable";
 import { useObservable } from "@vueuse/rxjs";
 
 interface ModelComponentRelationRecord {
@@ -115,12 +114,10 @@ export function useDataCollections(): {
     modelId: string,
   ): Ref<CollectionComponentGroup[] | undefined> {
     return useObservable(
-      // Dexie's liveQuery returns its own Observable-like type, not rxjs's Observable, so bridging needs a cast.
-      liveQuery(async () => {
+      liveObservable(async () => {
         const groups = await formatedCollectionComponents(modelId);
         return groups;
-        // oxlint-disable-next-line no-unsafe-type-assertion
-      }) as unknown as Observable<CollectionComponentGroup[]>,
+      }),
       {
         initialValue: undefined,
       },

package/app/stores/data_helpers/mesh.ts

@@ -1,6 +1,6 @@
-import { type Table, liveQuery } from "dexie";
-import type { Observable } from "rxjs";
+import type { Table } from "dexie";
 import { database } from "@ogw_internal/database/database.js";
+import { liveObservable } from "@ogw_front/utils/live_observable";
 import { useObservable } from "@vueuse/rxjs";
 
 interface ModelComponentRecord {
@@ -87,11 +87,10 @@ export function useDataMesh(): {
 
   function refFormatedMeshComponents(modelId: string): Ref<FormattedComponentGroup[] | undefined> {
     return useObservable(
-      liveQuery(async () => {
+      liveObservable(async () => {
         const components = await formatedMeshComponents(modelId);
         return components;
-        // oxlint-disable-next-line no-unsafe-type-assertion
-      }) as unknown as Observable<FormattedComponentGroup[]>,
+      }),
       {
         initialValue: undefined,
       },

package/app/stores/viewer.ts

@@ -142,12 +142,13 @@ export const useViewerStore = defineStore(
         }
         try {
           status.value = Status.CONNECTING;
-          client.value = (await initWebSocketClient(base_url.value, client.value, {
+          const wsClient = await initWebSocketClient(base_url.value, client.value, {
             onConnectionClose: () => {
               status.value = Status.NOT_CONNECTED;
             },
-            // oxlint-disable-next-line no-unsafe-type-assertion -- initWebSocketClient's return is not typed as RpcClient.
-          })) as unknown as RpcClient;
+          });
+          // oxlint-disable-next-line no-unsafe-type-assertion -- initWebSocketClient's return is not typed as RpcClient.
+          client.value = wsClient as unknown as RpcClient;
           connectImageStream(client.value.getConnection().getSession());
           // oxlint-disable-next-line no-unsafe-type-assertion -- endBusy is not part of the RpcClient type.
           (client.value as unknown as { endBusy: () => void }).endBusy();

package/app/utils/live_observable.ts

@@ -0,0 +1,14 @@
+// Third party imports
+import type { Observable } from "rxjs";
+import { liveQuery } from "dexie";
+
+// Dexie's liveQuery() returns Dexie's own minimal Observable shape, not an
+// Actual rxjs Observable instance (useObservable's declared parameter type);
+// The two are structurally close enough at runtime (vueuse only calls
+// `.subscribe`) but not identical, hence the cast.
+function liveObservable<Value>(query: () => Promise<Value>): Observable<Value> {
+  // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vueuse/Dexie Observable boundary; see comment above.
+  return liveQuery(query) as unknown as Observable<Value>;
+}
+
+export { liveObservable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.39.0-rc.1",
+  "version": "10.40.0-rc.1",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -69,6 +69,7 @@
     "@geode/opengeodeweb-viewer": "next",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",
+    "@msgpack/msgpack": "2.8.0",
     "@pinia/nuxt": "1.0.1",
     "@types/busboy": "1.5.4",
     "@types/node": "22.20.3",
@@ -101,7 +102,7 @@
     "vuetify": "4.2.0",
     "vuetify-nuxt-module": "1.0.0-rc.5",
     "ws": "8.21.2",
-    "wslink": "1.12.4",
+    "wslink": "2.5.0",
     "zod": "4.4.3"
   },
   "devDependencies": {

package/server/utils/cleanup.ts

@@ -4,11 +4,13 @@ import path from "node:path";
 import { setTimeout } from "node:timers/promises";
 
 // Third party imports
-import { WebSocket } from "ws";
 import { consola } from "consola";
 import pTimeout from "p-timeout";
 import { rimraf } from "rimraf";
 
+// Local imports
+import { createServerWsRpcClient } from "./ws_client.js";
+
 interface Microservice {
   type: "back" | "viewer";
   name: string;
@@ -88,49 +90,21 @@ async function killWebsocketMicroservice(microservice: Microservice): Promise<vo
     if (microservice.url === undefined) {
       return;
     }
-    const socketUrl = microservice.url;
+    const client = createServerWsRpcClient(microservice.url);
     // oxlint-disable-next-line promise/avoid-new
-    await new Promise<void>((resolve) => {
-      const socket = new WebSocket(socketUrl);
-      socket.on("open", () => {
-        consola.info("Connected to WebSocket server");
-        socket.send(
-          JSON.stringify({
-            id: "system:hello",
-            method: "wslink.hello",
-            args: [
-              {
-                secret: "wslink-secret",
-              },
-            ],
-          }),
-        );
-      });
-      socket.on("message", (data: Buffer | string) => {
-        const message = data.toString();
-        consola.debug("Received from server:", message);
-        if (message.includes("hello")) {
-          socket.send(
-            JSON.stringify({
-              id: "application.exit",
-              method: "application.exit",
-            }),
-          );
-          consola.info(successMessage);
-          socket.close();
-          resolve();
-        }
-      });
-      socket.on("close", () => {
-        consola.info(successMessage);
-        resolve();
-      });
-      socket.on("error", (error: Error) => {
-        consola.error("WebSocket error:", error);
-        socket.close();
-        resolve();
-      });
+    const closed = new Promise<void>((resolve) => {
+      client.onConnectionClose(resolve);
     });
+    try {
+      await client.notify("application.exit");
+      // Wslink handles messages asynchronously: closing right away would drop the exit request
+      await closed;
+      consola.info(successMessage);
+    } catch (error) {
+      consola.error("WebSocket error:", error);
+    } finally {
+      client.close();
+    }
   }
   await pTimeout(do_kill(), {
     milliseconds: 5000,

package/server/utils/ws_client.ts

@@ -1,4 +1,6 @@
 // Third party imports
+import { Decoder, encode } from "@msgpack/msgpack";
+import { UnChunker, generateChunks } from "wslink/src/WebsocketConnection/chunking.js";
 import { WebSocket } from "ws";
 import { v4 as uuidv4 } from "uuid";
 
@@ -6,6 +8,8 @@ import { v4 as uuidv4 } from "uuid";
 
 const HELLO_ID = "system:hello";
 const HELLO_SECRET = "wslink-secret";
+// Wslink default (512 KiB), until the hello response gives the server's limit
+const DEFAULT_MAX_MSG_SIZE = 524_288;
 
 interface PendingCall {
   resolve: (value: unknown) => void;
@@ -15,7 +19,7 @@ interface PendingCall {
 interface WsRpcMessage {
   id?: string;
   error?: { message?: string };
-  result?: unknown;
+  result?: { maxMsgSize?: number } & Record<string, unknown>;
 }
 
 function isWsRpcMessage(value: unknown): value is WsRpcMessage {
@@ -23,14 +27,11 @@ function isWsRpcMessage(value: unknown): value is WsRpcMessage {
 }
 
 // oxlint-disable-next-line prefer-readonly-parameter-types
-function rawDataToString(raw: WebSocket.RawData): string {
-  if (Buffer.isBuffer(raw)) {
-    return raw.toString();
+function rawDataToBlob(raw: WebSocket.RawData): Blob {
+  if (raw instanceof ArrayBuffer) {
+    return new Blob([raw]);
   }
-  if (Array.isArray(raw)) {
-    return Buffer.concat(raw).toString();
-  }
-  return Buffer.from(raw).toString();
+  return new Blob([Uint8Array.from(Array.isArray(raw) ? Buffer.concat(raw) : raw)]);
 }
 
 interface ServerWsRpcClient {
@@ -42,6 +43,7 @@ interface ServerWsRpcClient {
     };
   };
   isOpen: () => boolean;
+  notify: (method: string) => Promise<void>;
   onConnectionClose: (callback: () => void) => void;
   onConnectionError: (callback: (error: unknown) => void) => void;
   ready: Promise<void>;
@@ -51,35 +53,43 @@ interface ServerWsRpcClient {
 function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
   const socket = new WebSocket(baseUrl);
   const pending = new Map<string, PendingCall>();
+  // Wslink 2 messages are msgpack-encoded and split into chunks
+  const unChunker = new UnChunker();
+  let maxMsgSize = DEFAULT_MAX_MSG_SIZE;
   let onCloseCallback: (() => void) | undefined = undefined;
   let onErrorCallback: ((error: unknown) => void) | undefined = undefined;
 
+  function send(message: object): void {
+    for (const chunk of generateChunks(encode(message), maxMsgSize)) {
+      socket.send(chunk);
+    }
+  }
+
   //oxlint-disable-next-line promise/avoid-new max-lines-per-function
   const ready = new Promise<void>((resolve, reject) => {
     socket.on("open", () => {
-      socket.send(
-        JSON.stringify({
-          id: HELLO_ID,
-          method: "wslink.hello",
-          args: [{ secret: HELLO_SECRET }],
-        }),
-      );
+      send({
+        id: HELLO_ID,
+        method: "wslink.hello",
+        args: [{ secret: HELLO_SECRET }],
+      });
     });
 
     // oxlint-disable-next-line prefer-readonly-parameter-types
-    socket.on("message", (raw: WebSocket.RawData) => {
+    async function handleMessage(raw: WebSocket.RawData): Promise<void> {
       let message: WsRpcMessage | undefined = undefined;
       try {
-        const parsed: unknown = JSON.parse(rawDataToString(raw));
-        if (!isWsRpcMessage(parsed)) {
+        const decoded = await unChunker.processChunk(rawDataToBlob(raw), () => new Decoder());
+        if (!isWsRpcMessage(decoded)) {
           return;
         }
-        message = parsed;
+        message = decoded;
       } catch {
         return;
       }
 
       if (message.id === HELLO_ID) {
+        maxMsgSize = message.result?.maxMsgSize ?? maxMsgSize;
         resolve();
         return;
       }
@@ -98,6 +108,11 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
       } else {
         entry.resolve(message.result);
       }
+    }
+
+    // oxlint-disable-next-line prefer-readonly-parameter-types
+    socket.on("message", (raw: WebSocket.RawData) => {
+      void handleMessage(raw);
     });
 
     socket.on("error", (error: Error) => {
@@ -106,6 +121,7 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
     });
 
     socket.on("close", () => {
+      reject(new Error("WebSocket closed"));
       onCloseCallback?.();
       for (const { reject: rejectPending } of pending.values()) {
         rejectPending(new Error("WebSocket closed"));
@@ -120,18 +136,21 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
     //oxlint-disable-next-line promise/avoid-new
     return new Promise((resolve, reject) => {
       pending.set(id, { resolve, reject });
-      socket.send(
-        JSON.stringify({
-          wslink: "1.0",
-          id,
-          method: rpc,
-          args: [params],
-          kwargs: { stream: true },
-        }),
-      );
+      send({
+        id,
+        method: rpc,
+        args: [params],
+        kwargs: { stream: true },
+      });
     });
   }
 
+  // Call an RPC without arguments nor waiting for its response (e.g. "application.exit")
+  async function notify(method: string): Promise<void> {
+    await ready;
+    send({ id: method, method });
+  }
+
   function close(): void {
     socket.close();
   }
@@ -161,7 +180,16 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
     onErrorCallback = callback;
   }
 
-  return { call, close, getConnection, isOpen, onConnectionClose, onConnectionError, ready };
+  return {
+    call,
+    close,
+    getConnection,
+    isOpen,
+    notify,
+    onConnectionClose,
+    onConnectionError,
+    ready,
+  };
 }
 
 export { createServerWsRpcClient };

package/server/utils/wslink_chunking.d.ts

@@ -0,0 +1,12 @@
+// Wslink ships no types for its chunking module; this describes what ws_client.ts uses.
+declare module "wslink/src/WebsocketConnection/chunking.js" {
+  interface Decoder {
+    decode: (buffer: Uint8Array) => unknown;
+  }
+  function generateChunks(message: Uint8Array, maxSize: number): Generator<Uint8Array>;
+  class UnChunker {
+    public processChunk(chunk: Blob, decoderFactory: () => Decoder): Promise<unknown>;
+    public releasePendingMessages(): void;
+  }
+  export { UnChunker, generateChunks };
+}

package/shared/utils/call_raw.ts

@@ -26,12 +26,35 @@ interface CallRawOptions extends CallClientOptions {
   timeout?: number;
 }
 
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return _.isPlainObject(value);
+}
+
+// Wslink encodes messages with msgpack, which sends undefined values as null where JSON omitted them
+function omitUndefinedFields(record: object): Record<string, unknown> {
+  function omitUndefined(value: unknown): unknown {
+    if (Array.isArray(value)) {
+      return value.map((item: unknown) => omitUndefined(item));
+    }
+    if (isPlainRecord(value)) {
+      return omitUndefinedFields(value);
+    }
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(record)
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => [key, omitUndefined(value)]),
+  );
+}
+
 async function callClient({ rpc, params = {}, client }: CallClientOptions): Promise<unknown> {
+  const definedParams = omitUndefinedFields(params);
   if (globalThis.window !== undefined) {
-    const response = await client.getConnection().getSession().call(rpc, [params]);
+    const response = await client.getConnection().getSession().call(rpc, [definedParams]);
     return response;
   }
-  const response = await client.call(rpc, params);
+  const response = await client.call(rpc, definedParams);
   return response;
 }