@geode/opengeodeweb-front 10.34.0-rc.8 → 10.34.0

package/app/stores/data_helpers/mesh.ts

@@ -1,11 +1,7 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-import { liveQuery } from "dexie";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { Table } from "dexie";
+import { type Table, liveQuery } from "dexie";
+import type { Observable } from "rxjs";
 import { database } from "@ogw_internal/database/database.js";
 import { useObservable } from "@vueuse/rxjs";
-import type { Observable } from "rxjs";
 
 interface ModelComponentRecord {
   id: string;
@@ -17,17 +13,17 @@ interface ModelComponentRecord {
 }
 
 interface FormattedComponent {
-  id: string;
-  title: string;
-  category: string;
-  viewer_id: number;
-  is_active: boolean;
+  readonly id: string;
+  readonly title: string;
+  readonly category: string;
+  readonly viewer_id: number;
+  readonly is_active: boolean;
 }
 
 interface FormattedComponentGroup {
   id: string;
   title: string;
-  children: FormattedComponent[];
+  readonly children: readonly FormattedComponent[];
 }
 
 function toFormattedComponent(meshComponent: ModelComponentRecord): FormattedComponent {
@@ -40,7 +36,20 @@ function toFormattedComponent(meshComponent: ModelComponentRecord): FormattedCom
   };
 }
 
-export function useDataMesh() {
+// oxlint-disable-next-line eslint/max-lines-per-function
+export function useDataMesh(): {
+  formatedMeshComponents: typeof formatedMeshComponents;
+  refFormatedMeshComponents: typeof refFormatedMeshComponents;
+  getMeshComponentsByType: typeof getMeshComponentsByType;
+  getAllMeshComponents: typeof getAllMeshComponents;
+  fetchAllMeshComponents: typeof fetchAllMeshComponents;
+  getMeshComponentGeodeIds: typeof getMeshComponentGeodeIds;
+  getCornersGeodeIds: typeof getCornersGeodeIds;
+  getLinesGeodeIds: typeof getLinesGeodeIds;
+  getSurfacesGeodeIds: typeof getSurfacesGeodeIds;
+  getBlocksGeodeIds: typeof getBlocksGeodeIds;
+} {
+  // oxlint-disable-next-line no-unsafe-type-assertion -- database's table map is dynamically typed at runtime.
   const model_components_db = database.model_components as unknown as Table<
     ModelComponentRecord,
     string
@@ -57,10 +66,8 @@ export function useDataMesh() {
 
     const componentsByType: Record<string, ModelComponentRecord[]> = {};
     for (const component_item of items) {
-      if (componentTitles[component_item.type]) {
-        if (!componentsByType[component_item.type]) {
-          componentsByType[component_item.type] = [];
-        }
+      if (componentTitles[component_item.type] !== undefined) {
+        componentsByType[component_item.type] ??= [];
         componentsByType[component_item.type]?.push(component_item);
       }
     }
@@ -70,19 +77,19 @@ export function useDataMesh() {
       .map((type) => ({
         id: type,
         title: componentTitles[type] ?? type,
-        children: (componentsByType[type] ?? []).map((item) => toFormattedComponent(item)),
+        children: (componentsByType[type] ?? []).map((item: ModelComponentRecord) =>
+          toFormattedComponent(item),
+        ),
       }));
   }
 
-  function refFormatedMeshComponents(modelId: string) {
-    // 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 refFormatedMeshComponents(modelId: string): Ref<FormattedComponentGroup[] | undefined> {
     return useObservable(
-      liveQuery(() => formatedMeshComponents(modelId)) as unknown as Observable<
-        FormattedComponentGroup[]
-      >,
+      liveQuery(async () => {
+        const components = await formatedMeshComponents(modelId);
+        return components;
+        // oxlint-disable-next-line no-unsafe-type-assertion
+      }) as unknown as Observable<FormattedComponentGroup[]>,
       {
         initialValue: undefined,
       },
@@ -97,12 +104,12 @@ export function useDataMesh() {
       .where("[id+type]")
       .equals([modelId, type])
       .toArray();
-    return components.map((item) => toFormattedComponent(item));
+    return components.map((item: ModelComponentRecord) => toFormattedComponent(item));
   }
 
   async function getAllMeshComponents(modelId: string): Promise<FormattedComponent[]> {
     const items = await model_components_db.where("id").equals(modelId).toArray();
-    return items.map((item) => toFormattedComponent(item));
+    return items.map((item: ModelComponentRecord) => toFormattedComponent(item));
   }
 
   async function fetchAllMeshComponents(
@@ -111,9 +118,7 @@ export function useDataMesh() {
     const components = await getAllMeshComponents(modelId);
     const byType: Record<string, FormattedComponent[]> = {};
     for (const component of components) {
-      if (!byType[component.category]) {
-        byType[component.category] = [];
-      }
+      byType[component.category] ??= [];
       byType[component.category]?.push(component);
     }
     return byType;
@@ -124,23 +129,27 @@ export function useDataMesh() {
       .where("[id+type]")
       .equals([modelId, type])
       .toArray();
-    return components.map((component) => component.geode_id);
+    return components.map((component: ModelComponentRecord) => component.geode_id);
   }
 
   async function getCornersGeodeIds(modelId: string): Promise<string[]> {
-    return await getMeshComponentGeodeIds(modelId, "Corner");
+    const geodeIds = await getMeshComponentGeodeIds(modelId, "Corner");
+    return geodeIds;
   }
 
   async function getLinesGeodeIds(modelId: string): Promise<string[]> {
-    return await getMeshComponentGeodeIds(modelId, "Line");
+    const geodeIds = await getMeshComponentGeodeIds(modelId, "Line");
+    return geodeIds;
   }
 
   async function getSurfacesGeodeIds(modelId: string): Promise<string[]> {
-    return await getMeshComponentGeodeIds(modelId, "Surface");
+    const geodeIds = await getMeshComponentGeodeIds(modelId, "Surface");
+    return geodeIds;
   }
 
   async function getBlocksGeodeIds(modelId: string): Promise<string[]> {
-    return await getMeshComponentGeodeIds(modelId, "Block");
+    const geodeIds = await getMeshComponentGeodeIds(modelId, "Block");
+    return geodeIds;
   }
 
   return {

package/app/stores/data_style.ts

@@ -1,54 +1,63 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
+import type {
+  ModelComponentStyle,
+  ModelComponentTypeStyle,
+  ObjectStyle,
+} from "@ogw_internal/stores/data_style/types";
+import type { Table } from "dexie";
 import { database } from "@ogw_internal/database/database.js";
 import { getDefaultStyle } from "@ogw_front/utils/default_styles";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 import { useMeshStyle } from "@ogw_internal/stores/data_style/mesh/index";
 import { useModelStyle } from "@ogw_internal/stores/data_style/model/index";
-import type {
-  ModelComponentStyle,
-  ModelComponentTypeStyle,
-  ObjectStyle,
-} from "@ogw_internal/stores/data_style/types";
 
 interface DataStyleSnapshot {
-  styles: Record<string, ObjectStyle>;
-  componentStyles: Record<string, ModelComponentStyle>;
-  modelComponentTypeStyles: Record<string, ModelComponentTypeStyle>;
+  readonly styles: Record<string, ObjectStyle>;
+  readonly componentStyles: Record<string, ModelComponentStyle>;
+  readonly modelComponentTypeStyles: Record<string, ModelComponentTypeStyle>;
 }
 
-// The database's table map is dynamically assembled at runtime (see internal/database/database.ts), so `noUncheckedIndexedAccess` sees these as possibly undefined even though they're always registered before this store is used; guard defensively rather than asserting.
-function requireTable<Table>(table: Table | undefined, name: string): Table {
-  if (!table) {
+// The database's table map is dynamically assembled at runtime (see internal/database/database.ts), so its exported type is a loose `{}`; cast it to the shape it actually has at runtime rather than widening every call site.
+type DatabaseTables = Record<string, Table<Record<string, unknown>, string> | undefined>;
+
+// `noUncheckedIndexedAccess` sees these as possibly undefined even though they're always registered before this store is used; guard defensively rather than asserting.
+function requireTable<TableValue>(table: TableValue | undefined, name: string): TableValue {
+  if (table === undefined) {
     throw new Error(`Database table not initialized: ${name}`);
   }
   return table;
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
 // oxlint-disable-next-line max-lines-per-function
 export const useDataStyleStore = defineStore("dataStyle", () => {
   const dataStyleState = useDataStyleState();
   const meshStyleStore = useMeshStyle();
   const modelStyleStore = useModelStyle();
   const dataStore = useDataStore();
-  const data_style_db = requireTable(database.data_style, "data_style");
+  // oxlint-disable-next-line no-unsafe-type-assertion -- the database Proxy is typed as `{}` at its export site; this cast documents its real runtime shape.
+  const typedDatabase = database as unknown as DatabaseTables;
+  const data_style_db = requireTable(typedDatabase.data_style, "data_style");
   const model_component_type_datastyle_db = requireTable(
-    database.model_component_type_datastyle,
+    typedDatabase.model_component_type_datastyle,
     "model_component_type_datastyle",
   );
   const component_datastyle_db = requireTable(
-    database.model_component_datastyle,
+    typedDatabase.model_component_datastyle,
     "model_component_datastyle",
   );
 
   async function addDataStyle(id: string, geode_object: string): Promise<void> {
+    const defaultStyle = getDefaultStyle(geode_object);
     await data_style_db.put(
-      structuredClone({ id, ...(getDefaultStyle(geode_object) as Record<string, unknown>) }),
+      structuredClone({ id, ...(isRecord(defaultStyle) ? defaultStyle : {}) }),
     );
   }
 
-  async function setVisibility(id: string, visibility: boolean) {
+  async function setVisibility(id: string, visibility: boolean): Promise<unknown> {
     const item = await dataStore.item(id);
     if (!(await dataStore.isItemViewable(item))) {
       return dataStyleState.mutateStyle(id, { visibility });
@@ -65,7 +74,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     throw new Error("Unknown viewer_type");
   }
 
-  async function applyDefaultStyle(id: string) {
+  async function applyDefaultStyle(id: string): Promise<unknown[]> {
     const item = await dataStore.item(id);
     if (!(await dataStore.isItemViewable(item))) {
       throw new Error(`applyDefaultStyle called for non-viewable item: ${id}`);
@@ -90,6 +99,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     };
   }
 
+  // oxlint-disable-next-line prefer-readonly-parameter-types -- ObjectStyle (external type) has a mutable index signature and mutable nested StyleValues fields that can't be marked readonly from here.
   async function importStores(snapshot: DataStyleSnapshot): Promise<void> {
     const stylesSnapshot = snapshot.styles;
     const componentStylesSnapshot = snapshot.componentStyles;
@@ -97,14 +107,24 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
 
     await dataStyleState.clear();
 
-    const style_promises = Object.entries(stylesSnapshot).map(([id, style]) =>
-      data_style_db.put(structuredClone({ ...style, id })),
+    const style_promises = Object.entries(stylesSnapshot).map(
+      // oxlint-disable-next-line prefer-readonly-parameter-types -- same external ObjectStyle limitation as above.
+      async ([id, style]: readonly [string, ObjectStyle]) => {
+        const key = await data_style_db.put(structuredClone({ ...style, id }));
+        return key;
+      },
     );
-    const component_style_promises = Object.values(componentStylesSnapshot).map((style) =>
-      component_datastyle_db.put(structuredClone(style)),
+    const component_style_promises = Object.values(componentStylesSnapshot).map(
+      async (style: ModelComponentStyle) => {
+        const key = await component_datastyle_db.put(structuredClone(style));
+        return key;
+      },
     );
     const model_component_type_style_promises = Object.values(modelComponentTypeStylesSnapshot).map(
-      (style) => model_component_type_datastyle_db.put(structuredClone(style)),
+      async (style: ModelComponentTypeStyle) => {
+        const key = await model_component_type_datastyle_db.put(structuredClone(style));
+        return key;
+      },
     );
 
     await Promise.all([
@@ -114,7 +134,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     ]);
   }
 
-  function applyAllStylesFromState() {
+  async function applyAllStylesFromState(): Promise<void> {
     const ids = Object.keys(dataStyleState.styles.value);
     const promises = ids.map(async (id) => {
       const meta = await dataStore.item(id);
@@ -123,12 +143,12 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
       }
       const viewerType = meta.viewer_type;
       if (viewerType === "mesh") {
-        return meshStyleStore.applyMeshStyle(id);
+        await meshStyleStore.applyMeshStyle(id);
       } else if (viewerType === "model") {
-        return modelStyleStore.applyModelStyle(id);
+        await modelStyleStore.applyModelStyle(id);
       }
     });
-    return Promise.all(promises);
+    await Promise.all(promises);
   }
 
   return {
@@ -143,3 +163,5 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     ...modelStyleStore,
   };
 });
+
+export type { DataStyleSnapshot };

package/app/stores/feedback.ts

@@ -21,9 +21,9 @@ export const useFeedbackStore = defineStore("feedback", {
     feedbacks_timeout_miliseconds: DEFAULT_FEEDBACKS_TIMEOUT_SECONDS * MILLISECONDS_IN_SECOND,
   }),
   actions: {
-    async add_error(code: number, route: string, name: string, description: string) {
+    add_error(code: number, route: string, name: string, description: string) {
       const feedbackId = uuidv4();
-      await this.feedbacks.push({
+      this.feedbacks.push({
         id: feedbackId,
         type: "error",
         code,
@@ -35,9 +35,9 @@ export const useFeedbackStore = defineStore("feedback", {
         this.delete_feedback(feedbackId);
       }, this.feedbacks_timeout_miliseconds);
     },
-    async add_success(description: string) {
+    add_success(description: string) {
       const feedbackId = uuidv4();
-      await this.feedbacks.push({
+      this.feedbacks.push({
         id: feedbackId,
         type: "success",
         description,
@@ -46,9 +46,9 @@ export const useFeedbackStore = defineStore("feedback", {
         this.delete_feedback(feedbackId);
       }, this.feedbacks_timeout_miliseconds);
     },
-    async add_warning(description: string) {
+    add_warning(description: string) {
       const feedbackId = uuidv4();
-      await this.feedbacks.push({
+      this.feedbacks.push({
         id: feedbackId,
         type: "warning",
         description,

package/app/stores/hybrid_viewer.ts

@@ -1,35 +1,30 @@
+import {
+  type ViewStreamLike,
+  useHybridViewerViewport,
+} from "@ogw_internal/stores/hybrid_viewer/viewport";
 import {
   applySnapshot,
   getCameraOptions,
   useHybridViewerCamera,
 } from "@ogw_internal/stores/hybrid_viewer/camera";
 import { BACKGROUND_COLOR } from "@ogw_internal/stores/hybrid_viewer/constants";
+import type { CameraOptions } from "@ogw_internal/stores/hybrid_viewer/vtk_types";
 import { useHybridViewerBrightness } from "@ogw_internal/stores/hybrid_viewer/brightness";
+import { useHybridViewerCore } from "@ogw_internal/stores/hybrid_viewer/core";
 import { useHybridViewerFilters } from "@ogw_internal/stores/hybrid_viewer/filters";
 import { useHybridViewerHighlight } from "@ogw_internal/stores/hybrid_viewer/highlight";
 import { useHybridViewerRuler } from "@ogw_internal/stores/hybrid_viewer/ruler";
 import { useHybridViewerScene } from "@ogw_internal/stores/hybrid_viewer/scene";
-import { useHybridViewerViewport } from "@ogw_internal/stores/hybrid_viewer/viewport";
 import { newInstance as vtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { vtkGenericRenderWindow as VtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
 
 import { Status } from "@ogw_front/utils/status";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-interface GenericRenderWindowHolder {
-  value?: VtkGenericRenderWindow;
-}
-
 // oxlint-disable max-lines-per-function, max-statements
 export const useHybridViewerStore = defineStore("hybridViewer", () => {
   const viewerStore = useViewerStore();
-  const genericRenderWindow = reactive<GenericRenderWindowHolder>({});
-  const status = ref(Status.NOT_CREATED);
-  const is_moving = ref(false);
-  const is_picking = ref(false);
+  const { genericRenderWindow, status, is_moving, is_picking, remoteRender } =
+    useHybridViewerCore();
   let imageStyle: CSSStyleDeclaration | undefined = undefined;
 
   const brightnessStore = useHybridViewerBrightness();
@@ -46,11 +41,14 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     if (!genericRenderWindow.value) {
       return;
     }
+    // oxlint-disable-next-line no-unsafe-assignment -- vtk.js has no types for getApiSpecificRenderWindow(); narrowed below.
     const webGLRenderWindow = genericRenderWindow.value.getApiSpecificRenderWindow();
-    const canvas = (
-      webGLRenderWindow as unknown as { getCanvas: () => HTMLCanvasElement }
-    ).getCanvas();
-    if (canvas && canvas.parentElement) {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vtk.js OpenGL render window API boundary.
+    const openGLRenderWindow = webGLRenderWindow as unknown as {
+      getCanvas: () => HTMLCanvasElement;
+    };
+    const canvas = openGLRenderWindow.getCanvas();
+    if (canvas.parentElement) {
       canvas.parentElement.style.cursor = value ? "crosshair" : "default";
     }
   });
@@ -64,22 +62,34 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
       background: BACKGROUND_COLOR,
       listenWindowResize: false,
     });
-    const webGLRenderWindow = genericRenderWindow.value.getApiSpecificRenderWindow() as unknown as {
-      getReferenceByName: (name: string) => { style: CSSStyleDeclaration };
-      setBackgroundImage: (image: unknown) => void;
-    };
+    const webGLRenderWindow =
+      // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vtk.js OpenGL render window API boundary.
+      genericRenderWindow.value.getApiSpecificRenderWindow() as unknown as {
+        getReferenceByName: (name: string) => { style: CSSStyleDeclaration };
+        setBackgroundImage: (image: unknown) => void;
+      };
     imageStyle = webGLRenderWindow.getReferenceByName("bgImage").style;
-    Object.assign(imageStyle, { transition: "opacity 0.1s ease-in", zIndex: 1 });
+    Object.assign(imageStyle, {
+      transition: "opacity 0.1s ease-in",
+      zIndex: 1,
+    });
     await viewerStore.ws_connect();
-    const imageStream = (
-      viewerStore.client as unknown as { getImageStream: () => any }
-    ).getImageStream();
+    // oxlint-disable-next-line no-unsafe-type-assertion -- trusted @kitware/vtk.js WebSocket client API boundary.
+    const clientApi = viewerStore.client as unknown as {
+      getImageStream: () => {
+        createViewStream: (id: string) => ViewStreamLike;
+      };
+    };
+    const imageStream = clientApi.getImageStream();
     viewportStore.viewStream.value = imageStream.createViewStream("-1");
     viewportStore.viewStream.value?.onImageReady((event: { image: unknown }) => {
       if (is_moving.value) {
         return;
       }
-      brightnessStore.latestImage.value = event.image as typeof brightnessStore.latestImage.value;
+      // oxlint-disable no-unsafe-type-assertion -- image payload shape is guaranteed by the viewer's onImageReady contract.
+      const latestImage = event.image as typeof brightnessStore.latestImage.value;
+      // oxlint-enable no-unsafe-type-assertion
+      brightnessStore.latestImage.value = latestImage;
       webGLRenderWindow.setBackgroundImage(event.image);
       if (imageStyle) {
         imageStyle.opacity = "1";
@@ -94,36 +104,15 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     status.value = Status.CREATED;
   }
 
-  let renderPromise: Promise<void> | undefined = undefined;
-  let renderPending = false;
-
-  function remoteRender(): Promise<void> {
-    if (renderPromise) {
-      renderPending = true;
-      return renderPromise;
-    }
-
-    renderPromise = (async () => {
-      try {
-        const schema = viewer_schemas.opengeodeweb_viewer.viewer.render;
-        await viewerStore.request({ schema });
-      } finally {
-        renderPromise = undefined;
-        if (renderPending) {
-          renderPending = false;
-          await remoteRender();
-        }
-      }
-    })();
-    return renderPromise;
-  }
-
-  function exportStores() {
+  function exportStores(): {
+    zScale: number;
+    camera_options: CameraOptions | Record<string, unknown>;
+  } {
     const renderer = genericRenderWindow.value?.getRenderer();
     const camera = renderer?.getActiveCamera();
     return {
       zScale: sceneStore.zScale.value,
-      camera_options: (camera ? getCameraOptions(camera) : undefined) || cameraStore.camera_options,
+      camera_options: (camera ? getCameraOptions(camera) : undefined) ?? cameraStore.camera_options,
     };
   }
 

package/app/stores/infra.ts

@@ -1,17 +1,17 @@
 import { Status } from "@ogw_front/utils/status";
 import { appMode } from "@ogw_shared/app_mode";
-import { registerRunningExtensions } from "@ogw_front/utils/extension";
 import { setAppBaseUrl } from "@ogw_shared/scripts";
-import { useAppStore } from "@ogw_front/stores/app";
 import { useCloudStore } from "@ogw_front/stores/cloud";
 
-export interface Microservice {
-  $id: string;
-  status?: string;
-  is_busy?: boolean;
-  launch?: (params: Record<string, unknown>) => Promise<unknown>;
-  connect: () => Promise<void>;
-  [key: string]: unknown;
+interface ElectronApi {
+  electronAPI: {
+    project_folder_path: (args: { projectFolderPath: string }) => void;
+  };
+}
+
+declare global {
+  // oxlint-disable-next-line no-var -- required for global augmentation
+  var electronAPI: ElectronApi["electronAPI"];
 }
 
 export const useInfraStore = defineStore("infra", {
@@ -23,82 +23,84 @@ export const useInfraStore = defineStore("infra", {
   }),
   getters: {
     microservices_connected(): boolean {
-      console.log("microservices", this.microservices);
-      return this.microservices.every((store) => store.status === Status.CONNECTED);
+      return this.microservices.every((store: Microservice) => store.status === Status.CONNECTED);
     },
     microservices_busy(): boolean {
-      return this.microservices.some((store) => store.is_busy === true);
+      return this.microservices.some((store: Microservice) => store.is_busy === true);
     },
   },
   actions: {
     register_microservice(store: Microservice) {
       const store_name = store.$id;
-      console.log("[INFRA] Registering microservice:", store_name);
 
-      if (!this.microservices.some((microservice) => microservice.$id === store_name)) {
+      if (
+        !this.microservices.some((microservice: Microservice) => microservice.$id === store_name)
+      ) {
         this.microservices.push(store);
-        console.log("[INFRA] Microservice registered:", store_name);
       }
     },
     unregister_microservice(microserviceId: string) {
-      console.log("[INFRA] Unregistering microservice:", microserviceId);
       this.microservices = this.microservices.filter(
-        (microservice) => microservice.$id !== microserviceId,
+        (microservice: Microservice) => microservice.$id !== microserviceId,
       );
-      console.log("[INFRA] Microservice unregistered:", microserviceId);
     },
-    create_backend(email?: string) {
-      console.log("[INFRA] Starting create_backend - Mode:", this.app_mode);
-      console.log(
-        "[INFRA] Registered microservices:",
-        this.microservices.map((store) => store.$id),
-      );
+    async create_backend(email?: string) {
       if (this.status === Status.CREATED) {
-        return;
+        return undefined;
       }
-      return navigator.locks.request("infra.create_backend", async () => {
+      await navigator.locks.request("infra.create_backend", async () => {
         if (this.status === Status.CREATED) {
           return;
         }
         this.status = Status.CREATING;
-        console.log("[INFRA] Lock granted for create_backend");
         if (this.app_mode === appMode.CLOUD) {
           const cloudStore = useCloudStore();
           await cloudStore.launch(email ?? "");
         } else {
+          const { useAppStore } = await import("@ogw_front/stores/app");
           const appStore = useAppStore();
           await appStore.createProjectFolder();
           if (this.app_mode === appMode.DESKTOP) {
-            (globalThis as any).electronAPI.project_folder_path({
+            globalThis.electronAPI.project_folder_path({
               projectFolderPath: appStore.projectFolderPath,
             });
           }
           await setAppBaseUrl(appStore.base_url);
-          const microservices_with_launch = this.microservices.filter((store) => store.launch);
-          const launch_promises = microservices_with_launch.map((store) =>
-            store.launch!({ projectFolderPath: appStore.projectFolderPath }),
+          const microservices_with_launch = this.microservices.filter(
+            (store: Microservice) => store.launch,
           );
+          const launch_promises = microservices_with_launch.map(async (store: Microservice) => {
+            const result = await store.launch?.({
+              projectFolderPath: appStore.projectFolderPath,
+            });
+            return result;
+          });
+          const { registerRunningExtensions } = await import("@ogw_front/utils/extension");
           launch_promises.push(registerRunningExtensions());
           await Promise.all(launch_promises);
         }
         this.status = Status.CREATED;
-        console.log("[INFRA] Backend created successfully");
         return this.create_connection();
       });
+      return undefined;
     },
     async create_connection() {
-      console.log("[INFRA] Starting create_connection");
       await Promise.all(
-        this.microservices.map(async (store) => {
-          console.log("[INFRA] Connecting to microservice:", store.$id);
+        this.microservices.map(async (store: Microservice) => {
           await store.connect();
-          console.log("[INFRA] Microservice connected:", store.$id);
         }),
       );
-      console.log("[INFRA] All microservices connected");
     },
   },
   share: {
     omit: ["microservices"],
   },
 });
+
+export interface Microservice {
+  $id: string;
+  status?: string;
+  is_busy?: boolean;
+  launch?: (params: Record<string, unknown>) => Promise<unknown>;
+  connect: () => Promise<void>;
+}