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

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/DragAndDrop.vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
-import { onMounted, onUnmounted, ref } from "vue";
 import DragAndDropInline from "./DragAndDropInternal/DragAndDropInline.vue";
 import DragAndDropOverlay from "./DragAndDropInternal/DragAndDropOverlay.vue";
+import type { UploadFile } from "@ogw_front/utils/upload_path";
 
 interface DragAndDropTexts {
   idle: string;
@@ -18,6 +18,7 @@ interface Props {
   inline?: boolean;
   showOverlay?: boolean;
   texts?: DragAndDropTexts;
+  directory?: boolean;
 }
 
 const {
@@ -33,10 +34,20 @@ const {
     drop: "Drop files here",
     loading: "Loading...",
   },
+  directory = false,
+  // oxlint-disable-next-line vue/max-props
 } = defineProps<Props>();
 
+const displayed_texts = computed<DragAndDropTexts>(() =>
+  directory
+    ? { ...texts, idle: "Click or drag and drop a folder", drop: "Drop the folder here" }
+    : texts,
+);
+
 const emit = defineEmits<{
-  "files-selected": [files: File[]];
+  "files-selected": [files: UploadFile[]];
+  "folders-ignored": [];
+  "folder-read-error": [message: string];
 }>();
 
 const isDragging = ref(false);
@@ -115,10 +126,70 @@ function onDragOver(event: DragEvent): void {
   }
 }
 
+async function readAllEntries(reader: FileSystemDirectoryReader): Promise<FileSystemEntry[]> {
+  // oxlint-disable-next-line promise/avoid-new
+  const batch = await new Promise<FileSystemEntry[]>((resolve, reject) => {
+    reader.readEntries(resolve, reject);
+  });
+  if (batch.length === 0) {
+    return [];
+  }
+  return [...batch, ...(await readAllEntries(reader))];
+}
+
+async function filesFromEntry(entry: FileSystemEntry, path: string): Promise<UploadFile[]> {
+  if (entry.isFile) {
+    // oxlint-disable-next-line promise/avoid-new
+    const file = await new Promise<File>((resolve, reject) => {
+      // oxlint-disable-next-line no-unsafe-type-assertion -- isFile guarantees a FileSystemFileEntry
+      (entry as FileSystemFileEntry).file(resolve, reject);
+    });
+    return [Object.assign(file, { relativePath: path })];
+  }
+  // oxlint-disable-next-line no-unsafe-type-assertion -- not a file, so a FileSystemDirectoryEntry
+  const children = await readAllEntries((entry as FileSystemDirectoryEntry).createReader());
+  const nested = await Promise.all(
+    children.map((child) => filesFromEntry(child, `${path}/${child.name}`)),
+  );
+  return nested.flat();
+}
+
+async function emitDroppedEntries(entries: FileSystemEntry[]): Promise<void> {
+  try {
+    const groups = await Promise.all(
+      entries.map(async (entry) => {
+        const files = await filesFromEntry(entry, entry.name);
+        // Files inside a dropped folder are all needed: never filtered out.
+        return entry.isDirectory ? files : files.filter((file) => isFileAccepted(file, accept));
+      }),
+    );
+    const files = groups.flat();
+    if (files.length > 0) {
+      emit("files-selected", files);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    emit("folder-read-error", message);
+  }
+}
+
 function onDrop(event: DragEvent): void {
   event.preventDefault();
   dragCounter.value = 0;
   isDragging.value = false;
+  // Entries must be read synchronously: the DataTransfer is emptied once the event returns.
+  const entries = [...(event.dataTransfer?.items ?? [])]
+    .map((item) => item.webkitGetAsEntry?.())
+    .filter((entry): entry is FileSystemEntry => entry !== null && entry !== undefined);
+  if (entries.some((entry) => entry.isDirectory)) {
+    if (directory) {
+      void emitDroppedEntries(entries);
+      return;
+    }
+    emit("folders-ignored");
+    void emitDroppedEntries(entries.filter((entry) => entry.isFile));
+    return;
+  }
   const files = [...(event.dataTransfer?.files ?? [])].filter((file) =>
     isFileAccepted(file, accept),
   );
@@ -181,7 +252,7 @@ defineExpose({ triggerFileDialog });
     v-if="inline"
     :is-dragging
     :loading
-    :texts
+    :texts="displayed_texts"
     :accept
     :show-extensions
     @click="triggerFileDialog"
@@ -193,13 +264,21 @@ defineExpose({ triggerFileDialog });
     :show-overlay
     :fullscreen
     :loading
-    :texts
+    :texts="displayed_texts"
     :multiple
     :accept
     :show-extensions
   />
 
-  <input ref="fileInput" type="file" class="d-none" :multiple :accept @change="handleFileSelect" />
+  <input
+    ref="fileInput"
+    type="file"
+    class="d-none"
+    :multiple
+    :accept
+    :webkitdirectory="directory"
+    @change="handleFileSelect"
+  />
 </template>
 
 <style>

package/app/components/FileSelector.vue

@@ -8,7 +8,7 @@ import { useBackStore } from "@ogw_front/stores/back";
 const schema = schemas.opengeodeweb_back.allowed_files;
 
 interface Emits {
-  update_values: [values: { files: unknown[]; autoUpload: boolean }];
+  update_values: [values: { files: unknown[]; autoUpload: boolean; time_series?: string[] }];
   increment_step: [];
   decrement_step: [];
 }
@@ -20,13 +20,21 @@ interface Props {
   files?: File[];
   autoUpload?: boolean;
   showOverlay?: boolean;
+  timeSeries?: boolean;
 }
 
-const { multiple, files = [], autoUpload = true, showOverlay = true } = defineProps<Props>();
+const {
+  multiple,
+  files = [],
+  autoUpload = true,
+  showOverlay = true,
+  timeSeries = false,
+} = defineProps<Props>();
 
 const internal_files = ref<File[]>(files);
 const internal_auto_upload = ref<boolean>(autoUpload);
 const accept = ref<string>("");
+const time_series = ref<string[]>([]);
 const loading = ref<boolean>(false);
 
 watch(
@@ -47,7 +55,12 @@ const toggle_loading = useToggle(loading);
 
 function files_uploaded_event(value: unknown[]): void {
   if (value.length > 0) {
-    emit("update_values", { files: value, autoUpload: false });
+    emit(
+      "update_values",
+      timeSeries
+        ? { files: value, autoUpload: false, time_series: time_series.value }
+        : { files: value, autoUpload: false },
+    );
     emit("increment_step");
   }
 }
@@ -56,7 +69,10 @@ async function get_allowed_files(): Promise<void> {
   toggle_loading();
   const backStore = useBackStore();
   const response = await backStore.request({ schema });
-  accept.value = response.extensions.map((extension) => `.${extension}`).join(",");
+  time_series.value = timeSeries ? response.time_series_extensions : [];
+  accept.value = [...response.data_extensions, ...time_series.value]
+    .map((extension) => `.${extension}`)
+    .join(",");
   toggle_loading();
 }
 

package/app/components/FileUploader.vue

@@ -1,5 +1,7 @@
 <script setup lang="ts">
+import { foldersIgnoredWarning } from "@ogw_front/utils/upload_path";
 import { useBackStore } from "@ogw_front/stores/back";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
 
 import CsvPreviewer from "@ogw_front/components/csv-preview/CsvPreviewer.vue";
 import DragAndDrop from "@ogw_front/components/DragAndDrop.vue";
@@ -72,6 +74,10 @@ async function onCsvConfirm(result: unknown): Promise<void> {
   csv_dialog.value = false;
 }
 
+function warnFoldersIgnored(): void {
+  useFeedbackStore().add_warning(foldersIgnoredWarning);
+}
+
 function processSelectedFiles(selected_files: UploadFile[]): void {
   if (multiple) {
     internal_files.value = [...internal_files.value, ...selected_files];
@@ -154,6 +160,7 @@ watch(
       :accept
       :inline="false"
       @files-selected="processSelectedFiles"
+      @folders-ignored="warnFoldersIgnored"
     />
   </template>
   <DragAndDrop
@@ -166,6 +173,7 @@ watch(
     :inline="!internal_files.length"
     :show-overlay="showOverlay"
     @files-selected="processSelectedFiles"
+    @folders-ignored="warnFoldersIgnored"
   />
 
   <v-card-text v-if="internal_files.length" class="mt-6 pa-0">

package/app/components/MissingFilesSelector.vue

@@ -1,19 +1,23 @@
 <script setup lang="ts">
 import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 
+import { matchExpectedFiles, uploadPath } from "@ogw_front/utils/upload_path";
+import DragAndDrop from "@ogw_front/components/DragAndDrop.vue";
 import FetchingData from "@ogw_front/components/FetchingData.vue";
 import FileUploader from "@ogw_front/components/FileUploader.vue";
 import { useBackStore } from "@ogw_front/stores/back";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
 
 // Files carry extra app-specific bookkeeping fields once picked up here.
-type UploadFile = File & { isConfigured?: boolean };
+type UploadFile = File & { isConfigured?: boolean; relativePath?: string };
 interface FilePlan {
   has_missing_files: boolean;
   mandatory_files: string[];
   additional_files: string[];
 }
 
-const schema = schemas.opengeodeweb_back.missing_files;
+const schema = schemas.opengeodeweb_back.data_missing_files;
+const time_series_schema = schemas.opengeodeweb_back.time_series_missing_files;
 
 interface Emits {
   update_values: [value: { additional_files: UploadFile[] }];
@@ -28,9 +32,16 @@ interface Props {
   geodeObjectType: string;
   filenames: string[];
   files?: UploadFile[];
+  timeSeries?: boolean;
 }
 
-const { multiple, geodeObjectType, filenames, files = [] } = defineProps<Props>();
+const {
+  multiple,
+  geodeObjectType,
+  filenames,
+  files = [],
+  timeSeries = false,
+} = defineProps<Props>();
 
 const accept = ref<string>("");
 const loading = ref<boolean>(false);
@@ -38,6 +49,7 @@ const has_missing_files = ref<boolean>(false);
 const mandatory_files = ref<string[]>([]);
 const additional_files = ref<string[]>([]);
 const toggle_loading = useToggle(loading);
+const uploading = ref<boolean>(false);
 
 function files_uploaded_event(value: UploadFile[]): void {
   emit("update_values", { additional_files: value });
@@ -63,6 +75,9 @@ async function missing_files(): Promise<void> {
         additional_files: [],
       });
     }
+    if (timeSeries) {
+      return backStore.request({ schema: time_series_schema, params: { filename } });
+    }
     const params = { geode_object_type: geodeObjectType, filename };
     return backStore.request({ schema, params });
   });
@@ -88,12 +103,61 @@ async function missing_files(): Promise<void> {
   toggle_loading();
 }
 
+// Time series: uploads the missing files found in the selected folder, then the files they
+// Reference in turn, until nothing is missing. The folder layout does not matter.
+async function upload_missing_from(
+  folder_files: UploadFile[],
+  uploaded: UploadFile[],
+): Promise<void> {
+  const expected = [...mandatory_files.value, ...additional_files.value];
+  const match = matchExpectedFiles(
+    folder_files.map((file) => uploadPath(file)),
+    expected,
+  );
+  if (match.status === "ambiguous") {
+    useFeedbackStore().add_warning(
+      `Several matching files for ${match.path}, select a more specific folder`,
+    );
+    return;
+  }
+  const found = expected.flatMap((expected_path, index) => {
+    const file = folder_files[match.indices[index] ?? -1];
+    return file && !uploaded.includes(file)
+      ? [Object.assign(file, { relativePath: expected_path })]
+      : [];
+  });
+  if (found.length === 0) {
+    useFeedbackStore().add_warning(`The selected folder does not contain: ${expected.join(", ")}`);
+    return;
+  }
+  const backStore = useBackStore();
+  await Promise.all(found.map((file) => backStore.upload(file)));
+  emit("update_values", { additional_files: [...uploaded, ...found] });
+  await missing_files();
+  if (has_missing_files.value) {
+    await upload_missing_from(folder_files, [...uploaded, ...found]);
+  }
+}
+
+async function upload_folder(folder_files: UploadFile[]): Promise<void> {
+  uploading.value = true;
+  try {
+    await upload_missing_from(folder_files, []);
+  } finally {
+    uploading.value = false;
+  }
+}
+
+function warn_folder_read_error(message: string): void {
+  useFeedbackStore().add_warning(`Could not read the dropped folder: ${message}`);
+}
+
 // oxlint-disable-next-line no-top-level-await
 await missing_files();
 </script>
 
 <template>
-  <FetchingData v-if="loading" />
+  <FetchingData v-if="loading || uploading" />
   <v-container v-else-if="has_missing_files">
     <v-row v-if="mandatory_files.length" align="center">
       <v-col cols="auto" class="pa-0">
@@ -115,7 +179,15 @@ await missing_files();
     </v-row>
     <v-row>
       <v-col cols="12">
+        <DragAndDrop
+          v-if="timeSeries"
+          directory
+          :show-extensions="false"
+          @files-selected="upload_folder"
+          @folder-read-error="warn_folder_read_error"
+        />
         <FileUploader
+          v-else
           v-bind="{ multiple, accept, files, autoUpload: false }"
           @files_uploaded="files_uploaded_event"
         />

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/components/TimeSeriesTargetSelector.vue

@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+
+import FetchingData from "@ogw_front/components/FetchingData.vue";
+import { useBackStore } from "@ogw_front/stores/back";
+import { useDataStore } from "@ogw_front/stores/data";
+
+const schema = schemas.opengeodeweb_back.time_series_allowed_objects;
+
+interface Target {
+  id: string;
+  name: string;
+  geode_object_type: string;
+}
+
+const emit = defineEmits<{
+  update_values: [values: { target_id: string; geode_object_type: string }];
+  increment_step: [];
+  decrement_step: [];
+}>();
+
+const { filename } = defineProps<{ filename: string }>();
+
+const loading = ref(true);
+const targets = ref<Target[]>([]);
+
+async function get_targets(): Promise<void> {
+  const backStore = useBackStore();
+  const dataStore = useDataStore();
+  const [{ allowed_objects }, items] = await Promise.all([
+    backStore.request({ schema, params: { filename } }),
+    dataStore.allItems(),
+  ]);
+  targets.value = items
+    .filter((item) => allowed_objects.includes(item.geode_object_type))
+    .map(({ id, name, geode_object_type }) => ({ id, name, geode_object_type }));
+  loading.value = false;
+}
+
+function select(target: Target): void {
+  emit("update_values", { target_id: target.id, geode_object_type: target.geode_object_type });
+  emit("increment_step");
+}
+
+// oxlint-disable-next-line no-top-level-await
+await get_targets();
+</script>
+
+<template>
+  <FetchingData v-if="loading" />
+  <v-alert
+    v-else-if="targets.length === 0"
+    data-testid="noTimeSeriesTarget"
+    type="warning"
+    variant="tonal"
+  >
+    No compatible model loaded. Import a model (BRep) first, then drop the time series again.
+  </v-alert>
+  <v-list v-else bg-color="transparent">
+    <v-list-item
+      v-for="target in targets"
+      :key="target.id"
+      data-testid="timeSeriesTarget"
+      :title="target.name"
+      :subtitle="target.geode_object_type"
+      prepend-icon="mdi-cube-outline"
+      @click="select(target)"
+    />
+  </v-list>
+</template>

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/import_workflow.ts

@@ -150,4 +150,29 @@ async function importWorkflowFromSnapshot(items: readonly NewDataItem[]): Promis
   });
   return ids;
 }
-export { importFile, importWorkflow, importWorkflowFromSnapshot, importItem };
+
+// The time series only adds attributes to the model, so the viewer object is reloaded under the same id with its stored style.
+async function applyTimeSeriesWorkflow(filename: string, id: string): Promise<string> {
+  const backStore = useBackStore();
+  const dataStore = useDataStore();
+  const dataStyleStore = useDataStyleStore();
+  const hybridViewerStore = useHybridViewerStore();
+  await backStore.request({
+    schema: back_schemas.opengeodeweb_back.apply_time_series,
+    params: { id, filename },
+  });
+  const item = await dataStore.item(id);
+  await dataStore.deregisterObject(id);
+  await dataStore.registerObject(id, item.name ?? id);
+  await dataStyleStore.applyDefaultStyle(id);
+  await hybridViewerStore.remoteRender();
+  return id;
+}
+
+export {
+  importFile,
+  importWorkflow,
+  importWorkflowFromSnapshot,
+  importItem,
+  applyTimeSeriesWorkflow,
+};

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/app/utils/upload_path.ts

@@ -0,0 +1,75 @@
+// Files carry extra app-specific bookkeeping fields once picked up by the uploader.
+type UploadFile = File & { relativePath?: string; isConfigured?: boolean; displayName?: string };
+
+// Path of the file inside the back upload folder: keeps the folder tree of a dropped directory.
+function uploadPath(file: UploadFile): string {
+  for (const candidate of [file.relativePath, file.webkitRelativePath]) {
+    if (candidate !== undefined && candidate !== "") {
+      return candidate;
+    }
+  }
+  return file.name;
+}
+
+function fileExtension(path: string): string {
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index + 1).toLowerCase();
+}
+
+type FileMatch =
+  | { status: "matched"; indices: (number | undefined)[] }
+  | { status: "ambiguous"; path: string };
+
+// Number of folders the two paths have in common, in order: 0 when the file names differ.
+function matchScore(path: string, expected_path: string): number {
+  const segments = path.split("/");
+  const expected_segments = expected_path.split("/");
+  if (segments.at(-1) !== expected_segments.at(-1)) {
+    return 0;
+  }
+  // Longest common subsequence of the path segments
+  let previous = Array.from({ length: expected_segments.length + 1 }, () => 0);
+  for (const segment of segments) {
+    const current = [0];
+    for (const [index, expected_segment] of expected_segments.entries()) {
+      current.push(
+        segment === expected_segment
+          ? (previous[index] ?? 0) + 1
+          : Math.max(previous[index + 1] ?? 0, current[index] ?? 0),
+      );
+    }
+    previous = current;
+  }
+  return previous.at(-1) ?? 0;
+}
+
+// Finds each expected file in a selected folder, whatever the folder layout: a selected file is
+// Kept for an expected path when each is the other's closest match (most folders in common).
+// Gives, for each expected path, the index of its selected path (undefined when not found).
+function matchExpectedFiles(paths: readonly string[], expected: readonly string[]): FileMatch {
+  const scores = expected.map((expected_path) =>
+    paths.map((path) => matchScore(path, expected_path)),
+  );
+  const path_best_scores = paths.map((_path, index) =>
+    Math.max(0, ...scores.map((expected_scores) => expected_scores[index] ?? 0)),
+  );
+  const indices: (number | undefined)[] = [];
+  for (const [expected_index, expected_scores] of scores.entries()) {
+    const best = Math.max(0, ...expected_scores);
+    const candidates = expected_scores.flatMap((score, index) =>
+      best > 0 && score === best && path_best_scores[index] === best ? [index] : [],
+    );
+    if (candidates.length > 1) {
+      return { status: "ambiguous", path: expected[expected_index] ?? "" };
+    }
+    indices.push(candidates[0]);
+  }
+  return { status: "matched", indices };
+}
+
+// Shared by every drop zone that refuses folders.
+const foldersIgnoredWarning = "Folders can't be dropped here";
+
+export { fileExtension, foldersIgnoredWarning, matchExpectedFiles, uploadPath };
+export type { UploadFile };

package/internal/utils/upload_file.ts

@@ -3,6 +3,7 @@ import { CHUNK_SIZE_BYTES } from "@ogw_shared/utils/file.js";
 import type { Microservice } from "./api_fetch.js";
 import { consola } from "consola";
 import { fetchRaw } from "@ogw_shared/utils/fetch_raw.js";
+import { uploadPath } from "@ogw_front/utils/upload_path";
 import { useFeedbackStore } from "@ogw_front/stores/feedback.js";
 
 interface UploadFileParams {
@@ -86,7 +87,7 @@ async function upload_file(
     const chunk = file.slice(start, start + CHUNK_SIZE_BYTES);
     const query = new URLSearchParams({
       ...params,
-      filename: file.name,
+      filename: uploadPath(file),
       chunk_index: String(chunkIndex),
       total_chunks: String(totalChunks),
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.39.0",
+  "version": "10.40.0-rc.2",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -64,11 +64,12 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@geode/cloud-api": "latest",
-    "@geode/opengeodeweb-back": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/cloud-api": "next",
+    "@geode/opengeodeweb-back": "next",
+    "@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;
 }