Fixup type errors due to new Runnable requirements

Signed-off-by: Sebastian Malton <sebastian@malton.name>

packages/core/src/common/k8s-api/__tests__/kube-api-version-detection.test.ts

@@ -121,7 +121,7 @@ describe("KubeApi", () => {
         ]);
       });
 
-      describe("when resource request fufills with a resource", () => {
+      describe("when resource request fulfills with a resource", () => {
         beforeEach(async () => {
           await fetchMock.resolveSpecific(
             ["https://127.0.0.1:12345/api-kube/apis/networking.k8s.io/v1"],
@@ -283,7 +283,7 @@ describe("KubeApi", () => {
         });
       });
 
-      describe("when resource request fufills with no resource", () => {
+      describe("when resource request fulfills with no resource", () => {
         beforeEach(async () => {
           await fetchMock.resolveSpecific(
             ["https://127.0.0.1:12345/api-kube/apis/networking.k8s.io/v1"],
@@ -307,7 +307,7 @@ describe("KubeApi", () => {
 
 
 
-        describe("when resource request fufills with a resource", () => {
+        describe("when resource request fulfills with a resource", () => {
           beforeEach(async () => {
             await fetchMock.resolveSpecific(
               ["https://127.0.0.1:12345/api-kube/apis/networking.k8s.io/v1beta1"],
@@ -509,7 +509,7 @@ describe("KubeApi", () => {
         ]);
       });
 
-      describe("when resource request fufills with a resource", () => {
+      describe("when resource request fulfills with a resource", () => {
         beforeEach(async () => {
           await fetchMock.resolveSpecific(
             ["https://127.0.0.1:12345/api-kube/apis/extensions"],

packages/core/src/features/application-menu/main/start-application-menu.injectable.ts

@@ -4,23 +4,18 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import applicationMenuReactivityInjectable from "./application-menu-reactivity.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../../main/start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../../main/start-main-application/runnable-tokens/phases";
 
 const startApplicationMenuInjectable = getInjectable({
   id: "start-application-menu",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const applicationMenu = di.inject(
+    run: () => {
-      applicationMenuReactivityInjectable,
+      const applicationMenu = di.inject(applicationMenuReactivityInjectable);
-    );
 
-    return {
+      applicationMenu.start();
-      id: "start-application-menu",
+    },
-      run: () => {
+  }),
-        applicationMenu.start();
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/features/application-menu/main/stop-application-menu.injectable.ts

@@ -4,19 +4,20 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import applicationMenuReactivityInjectable from "./application-menu-reactivity.injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../../main/start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../../main/start-main-application/runnable-tokens/phases";
 
 const stopApplicationMenuInjectable = getInjectable({
   id: "stop-application-menu",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const applicationMenu = di.inject(applicationMenuReactivityInjectable);
+    run: () => {
+      const applicationMenu = di.inject(applicationMenuReactivityInjectable);
 
-    return {
+      applicationMenu.stop();
-      id: "stop-application-menu",
+
-      run: () => void applicationMenu.stop(),
+      return undefined;
-    };
+    },
-  },
+  }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/features/application-update/child-features/periodical-checking-of-updates/main/start-checking-for-updates.injectable.ts

@@ -5,24 +5,21 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import periodicalCheckForUpdatesInjectable from "./periodical-check-for-updates.injectable";
 import updatingIsEnabledInjectable from "../../../main/updating-is-enabled/updating-is-enabled.injectable";
-import { afterApplicationIsLoadedInjectionToken } from "../../../../../main/start-main-application/runnable-tokens/after-application-is-loaded-injection-token";
+import { afterApplicationIsLoadedInjectionToken } from "../../../../../main/start-main-application/runnable-tokens/phases";
 
 const startCheckingForUpdatesInjectable = getInjectable({
   id: "start-checking-for-updates",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const periodicalCheckForUpdates = di.inject(periodicalCheckForUpdatesInjectable);
+    run: () => {
-    const updatingIsEnabled = di.inject(updatingIsEnabledInjectable);
+      const periodicalCheckForUpdates = di.inject(periodicalCheckForUpdatesInjectable);
+      const updatingIsEnabled = di.inject(updatingIsEnabledInjectable);
 
-    return {
+      if (updatingIsEnabled && !periodicalCheckForUpdates.started) {
-      id: "start-checking-for-updates",
+        periodicalCheckForUpdates.start();
-      run: () => {
+      }
-        if (updatingIsEnabled && !periodicalCheckForUpdates.started) {
+    },
-          periodicalCheckForUpdates.start();
+  }),
-        }
-      },
-    };
-  },
 
   injectionToken: afterApplicationIsLoadedInjectionToken,
 });

packages/core/src/features/application-update/child-features/periodical-checking-of-updates/main/stop-checking-for-updates.injectable.ts

@@ -4,25 +4,22 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import periodicalCheckForUpdatesInjectable from "./periodical-check-for-updates.injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../../../../main/start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../../../../main/start-main-application/runnable-tokens/phases";
 
 const stopCheckingForUpdatesInjectable = getInjectable({
   id: "stop-checking-for-updates",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const periodicalCheckForUpdates = di.inject(periodicalCheckForUpdatesInjectable);
+    run: () => {
+      const periodicalCheckForUpdates = di.inject(periodicalCheckForUpdatesInjectable);
 
-    return {
+      if (periodicalCheckForUpdates.started) {
-      id: "stop-checking-for-updates",
+        periodicalCheckForUpdates.stop();
-      run: () => {
+      }
-        if (periodicalCheckForUpdates.started) {
-          periodicalCheckForUpdates.stop();
-        }
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/features/application-update/main/emit-current-version-to-analytics.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { afterApplicationIsLoadedInjectionToken } from "../../../main/start-main-application/runnable-tokens/after-application-is-loaded-injection-token";
+import { afterApplicationIsLoadedInjectionToken } from "../../../main/start-main-application/runnable-tokens/phases";
 import emitAppEventInjectable from "../../../common/app-event-bus/emit-event.injectable";
 import { getCurrentDateTime } from "../../../common/utils/date/get-current-date-time";
 import buildVersionInjectable from "../../../main/vars/build-version/build-version.injectable";
@@ -11,25 +11,22 @@ import buildVersionInjectable from "../../../main/vars/build-version/build-versi
 const emitCurrentVersionToAnalyticsInjectable = getInjectable({
   id: "emit-current-version-to-analytics",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const emitAppEvent = di.inject(emitAppEventInjectable);
+    run: () => {
-    const buildVersion = di.inject(buildVersionInjectable);
+      const emitAppEvent = di.inject(emitAppEventInjectable);
+      const buildVersion = di.inject(buildVersionInjectable);
 
-    return {
+      emitAppEvent({
-      id: "emit-current-version-to-analytics",
+        name: "app",
-      run: () => {
+        action: "current-version",
-        emitAppEvent({
-          name: "app",
-          action: "current-version",
 
-          params: {
+        params: {
-            version: buildVersion.get(),
+          version: buildVersion.get(),
-            currentDateTime: getCurrentDateTime(),
+          currentDateTime: getCurrentDateTime(),
-          },
+        },
-        });
+      });
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: afterApplicationIsLoadedInjectionToken,
 });

packages/core/src/features/application-update/main/watch-if-update-should-happen-on-quit/start-watching-if-update-should-happen-on-quit.injectable.ts

@@ -3,22 +3,19 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { onLoadOfApplicationInjectionToken } from "../../../../main/start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../../../main/start-main-application/runnable-tokens/phases";
 import watchIfUpdateShouldHappenOnQuitInjectable from "./watch-if-update-should-happen-on-quit.injectable";
 
 const startWatchingIfUpdateShouldHappenOnQuitInjectable = getInjectable({
   id: "start-watching-if-update-should-happen-on-quit",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const watchIfUpdateShouldHappenOnQuit = di.inject(watchIfUpdateShouldHappenOnQuitInjectable);
+    run: () => {
+      const watchIfUpdateShouldHappenOnQuit = di.inject(watchIfUpdateShouldHappenOnQuitInjectable);
 
-    return {
+      watchIfUpdateShouldHappenOnQuit.start();
-      id: "start-watching-if-update-should-happen-on-quit",
+    },
-      run: () => {
+  }),
-        watchIfUpdateShouldHappenOnQuit.start();
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/features/application-update/main/watch-if-update-should-happen-on-quit/stop-watching-if-update-should-happen-on-quit.injectable.ts

@@ -4,19 +4,20 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import watchIfUpdateShouldHappenOnQuitInjectable from "./watch-if-update-should-happen-on-quit.injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../../../main/start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../../../main/start-main-application/runnable-tokens/phases";
 
 const stopWatchingIfUpdateShouldHappenOnQuitInjectable = getInjectable({
   id: "stop-watching-if-update-should-happen-on-quit",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const watchIfUpdateShouldHappenOnQuit = di.inject(watchIfUpdateShouldHappenOnQuitInjectable);
+    run: () => {
+      const watchIfUpdateShouldHappenOnQuit = di.inject(watchIfUpdateShouldHappenOnQuitInjectable);
 
-    return {
+      watchIfUpdateShouldHappenOnQuit.stop();
-      id: "stop-watching-if-update-should-happen-on-quit",
+
-      run: () => void watchIfUpdateShouldHappenOnQuit.stop(),
+      return undefined;
-    };
+    },
-  },
+  }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/features/cluster/state-sync/main/setup-sync.injectable.ts

@@ -7,14 +7,13 @@ import { isEqual } from "lodash";
 import { autorun } from "mobx";
 import clusterStoreInjectable from "../../../../common/cluster-store/cluster-store.injectable";
 import type { ClusterId, ClusterState } from "../../../../common/cluster-types";
-import { beforeApplicationIsLoadingInjectionToken } from "../../../../main/start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../../../../main/start-main-application/runnable-tokens/phases";
 import initClusterStoreInjectable from "../../store/main/init.injectable";
 import emitClusterStateUpdateInjectable from "./emit-update.injectable";
 
 const setupClusterStateBroadcastingInjectable = getInjectable({
   id: "setup-cluster-state-broadcasting",
   instantiate: (di) => ({
-    id: "setup-cluster-state-broadcasting",
     run: () => {
       const emitClusterStateUpdate = di.inject(emitClusterStateUpdateInjectable);
       const clusterStore = di.inject(clusterStoreInjectable);
@@ -36,7 +35,7 @@ const setupClusterStateBroadcastingInjectable = getInjectable({
         }
       });
     },
-    runAfter: di.inject(initClusterStoreInjectable),
+    runAfter: initClusterStoreInjectable,
   }),
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });

packages/core/src/features/cluster/state-sync/renderer/setup-sync.injectable.ts

@@ -11,17 +11,16 @@ import requestInitialClusterStatesInjectable from "./request-initial.injectable"
 const setupClusterStateSyncInjectable = getInjectable({
   id: "setup-cluster-state-sync",
   instantiate: (di) => ({
-    id: "setup-cluster-state-sync",
     run: async () => {
       const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
       const getClusterById = di.inject(getClusterByIdInjectable);
-      const initalStates = await requestInitialClusterStates();
+      const initialStates = await requestInitialClusterStates();
 
-      for (const { clusterId, state } of initalStates) {
+      for (const { clusterId, state } of initialStates) {
         getClusterById(clusterId)?.setState(state);
       }
     },
-    runAfter: di.inject(initClusterStoreInjectable),
+    runAfter: initClusterStoreInjectable,
   }),
   injectionToken: beforeFrameStartsSecondInjectionToken,
 });

packages/core/src/features/cluster/store/main/init.injectable.ts

@@ -4,22 +4,19 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import clusterStoreInjectable from "../../../../common/cluster-store/cluster-store.injectable";
-import { beforeApplicationIsLoadingInjectionToken } from "../../../../main/start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../../../../main/start-main-application/runnable-tokens/phases";
 import initUserStoreInjectable from "../../../../main/stores/init-user-store.injectable";
 
 const initClusterStoreInjectable = getInjectable({
   id: "init-cluster-store",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const clusterStore = di.inject(clusterStoreInjectable);
+    run: () => {
+      const clusterStore = di.inject(clusterStoreInjectable);
 
-    return {
+      clusterStore.load();
-      id: "init-cluster-store",
+    },
-      run: () => {
+    runAfter: initUserStoreInjectable,
-        clusterStore.load();
+  }),
-      },
-      runAfter: di.inject(initUserStoreInjectable),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

packages/core/src/features/cluster/store/renderer/init.injectable.ts

@@ -10,13 +10,12 @@ import initUserStoreInjectable from "../../../../renderer/stores/init-user-store
 const initClusterStoreInjectable = getInjectable({
   id: "init-cluster-store",
   instantiate: (di) => ({
-    id: "init-cluster-store",
     run: () => {
       const clusterStore = di.inject(clusterStoreInjectable);
 
       clusterStore.load();
     },
-    runAfter: di.inject(initUserStoreInjectable),
+    runAfter: initUserStoreInjectable,
   }),
   injectionToken: beforeFrameStartsSecondInjectionToken,
 });

packages/core/src/features/file-system-provisioner/main/init-store.injectable.ts

@@ -4,12 +4,11 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import fileSystemProvisionerStoreInjectable from "../../../extensions/extension-loader/file-system-provisioner-store/file-system-provisioner-store.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../../main/start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../../main/start-main-application/runnable-tokens/phases";
 
 const initFileSystemProvisionerStoreInjectable = getInjectable({
   id: "init-file-system-provisioner-store",
   instantiate: (di) => ({
-    id: "init-file-system-provisioner-store",
     run: () => {
       const store = di.inject(fileSystemProvisionerStoreInjectable);
 

packages/core/src/features/file-system-provisioner/renderer/init-store.injectable.ts

@@ -9,7 +9,6 @@ import { beforeFrameStartsSecondInjectionToken } from "../../../renderer/before-
 const initFileSystemProvisionerStoreInjectable = getInjectable({
   id: "init-file-system-provisioner-store",
   instantiate: (di) => ({
-    id: "init-file-system-provisioner-store",
     run: () => {
       const store = di.inject(fileSystemProvisionerStoreInjectable);
 

packages/core/src/features/hotbar/store/main/init.injectable.ts

@@ -4,22 +4,19 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import hotbarStoreInjectable from "../../../../common/hotbars/store.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../../../main/start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../../../main/start-main-application/runnable-tokens/phases";
 import setupSyncingOfGeneralCatalogEntitiesInjectable from "../../../../main/start-main-application/runnables/setup-syncing-of-general-catalog-entities.injectable";
 
 const initHotbarStoreInjectable = getInjectable({
   id: "init-hotbar-store",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const hotbarStore = di.inject(hotbarStoreInjectable);
+    run: () => {
+      const hotbarStore = di.inject(hotbarStoreInjectable);
 
-    return {
+      hotbarStore.load();
-      id: "init-hotbar-store",
+    },
-      run: () => {
+    runAfter: setupSyncingOfGeneralCatalogEntitiesInjectable,
-        hotbarStore.load();
+  }),
-      },
-      runAfter: di.inject(setupSyncingOfGeneralCatalogEntitiesInjectable),
-    };
-  },
   injectionToken: onLoadOfApplicationInjectionToken,
 });
 

packages/core/src/features/hotbar/store/renderer/init.injectable.ts

@@ -10,13 +10,12 @@ import initClusterStoreInjectable from "../../../cluster/store/renderer/init.inj
 const initHotbarStoreInjectable = getInjectable({
   id: "init-hotbar-store",
   instantiate: (di) => ({
-    id: "init-hotbar-store",
     run: () => {
       const hotbarStore = di.inject(hotbarStoreInjectable);
 
       hotbarStore.load();
     },
-    runAfter: di.inject(initClusterStoreInjectable),
+    runAfter: initClusterStoreInjectable,
   }),
   injectionToken: beforeFrameStartsSecondInjectionToken,
 });

packages/core/src/features/shell-sync/main/setup-shell.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import loggerInjectable from "../../../common/logger.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../../main/start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../../main/start-main-application/runnable-tokens/phases";
 import { unionPATHs } from "../../../common/utils/union-env-path";
 import isSnapPackageInjectable from "../../../common/vars/is-snap-package.injectable";
 import electronAppInjectable from "../../../main/electron-app/electron-app.injectable";
@@ -15,57 +15,56 @@ import emitShellSyncFailedInjectable from "./emit-failure.injectable";
 const setupShellInjectable = getInjectable({
   id: "setup-shell",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const logger = di.inject(loggerInjectable);
+    run: async () => {
-    const isSnapPackage = di.inject(isSnapPackageInjectable);
+      const logger = di.inject(loggerInjectable);
-    const electronApp = di.inject(electronAppInjectable);
+      const isSnapPackage = di.inject(isSnapPackageInjectable);
-    const resolvedUserShellSetting = di.inject(userShellSettingInjectable);
+      const electronApp = di.inject(electronAppInjectable);
-    const computeShellEnvironment = di.inject(computeShellEnvironmentInjectable);
+      const resolvedUserShellSetting = di.inject(userShellSettingInjectable);
-    const emitShellSyncFailed = di.inject(emitShellSyncFailedInjectable);
+      const computeShellEnvironment = di.inject(computeShellEnvironmentInjectable);
+      const emitShellSyncFailed = di.inject(emitShellSyncFailedInjectable);
 
-    return {
+      logger.info("🐚 Syncing shell environment");
-      id: "setup-shell",
-      run: async (): Promise<void> => {
-        logger.info("🐚 Syncing shell environment");
 
-        const result = await computeShellEnvironment(resolvedUserShellSetting.get());
+      const result = await computeShellEnvironment(resolvedUserShellSetting.get());
 
-        if (!result.callWasSuccessful) {
+      if (!result.callWasSuccessful) {
-          logger.error(`[SHELL-SYNC]: ${result.error}`);
+        logger.error(`[SHELL-SYNC]: ${result.error}`);
-          emitShellSyncFailed(result.error);
+        emitShellSyncFailed(result.error);
 
-          return;
+        return;
-        }
+      }
 
-        const env = result.response;
+      const env = result.response;
 
-        if (!env) {
+      if (!env) {
-          return void logger.debug("[SHELL-SYNC]: nothing to do, env not special in shells");
+        logger.debug("[SHELL-SYNC]: nothing to do, env not special in shells");
-        }
 
-        if (!env.LANG) {
+        return;
-          // the LANG env var expects an underscore instead of electron's dash
+      }
-          env.LANG = `${electronApp.getLocale().replace("-", "_")}.UTF-8`;
-        } else if (!env.LANG.endsWith(".UTF-8")) {
-          env.LANG += ".UTF-8";
-        }
 
-        if (!isSnapPackage) {
+      if (!env.LANG) {
-          // Prefer the synced PATH over the initial one
+        // the LANG env var expects an underscore instead of electron's dash
-          process.env.PATH = unionPATHs(env.PATH ?? "",  process.env.PATH ?? "");
+        env.LANG = `${electronApp.getLocale().replace("-", "_")}.UTF-8`;
-        }
+      } else if (!env.LANG.endsWith(".UTF-8")) {
+        env.LANG += ".UTF-8";
+      }
 
-        // The spread operator allows joining of objects. The precedence is last to first.
+      if (!isSnapPackage) {
-        process.env = {
+        // Prefer the synced PATH over the initial one
-          ...env,
+        process.env.PATH = unionPATHs(env.PATH ?? "", process.env.PATH ?? "");
-          ...process.env,
+      }
-        };
 
-        logger.info(`[SHELL-SYNC]: Synced shell env`);
+      // The spread operator allows joining of objects. The precedence is last to first.
-        logger.debug(`[SHELL-SYNC]: updated env`, process.env);
+      process.env = {
-      },
+        ...env,
-    };
+        ...process.env,
-  },
+      };
+
+      logger.info(`[SHELL-SYNC]: Synced shell env`);
+      logger.debug(`[SHELL-SYNC]: updated env`, process.env);
+    },
+  }),
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/features/terminal/renderer/fonts/preload-fonts.injectable.ts

@@ -10,7 +10,6 @@ import loadTerminalFontInjectable from "./load-font.injectable";
 const preloadTerminalFontsInjectable = getInjectable({
   id: "preload-terminal-fonts",
   instantiate: (di) => ({
-    id: "preload-terminal-fonts",
     run: async () => {
       const terminalFonts = di.inject(terminalFontsInjectable);
       const loadTerminalFont = di.inject(loadTerminalFontInjectable);

packages/core/src/features/theme/system-type/main/setup-update-emitter.injectable.ts

@@ -4,29 +4,26 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { reaction } from "mobx";
-import { onLoadOfApplicationInjectionToken } from "../../../../main/start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../../../main/start-main-application/runnable-tokens/phases";
 import operatingSystemThemeInjectable from "../../../../main/theme/operating-system-theme.injectable";
 import emitSystemThemeTypeUpdateInjectable from "./emit-update.injectable";
 
 const setupSystemThemeTypeUpdaterEmitterInjectable = getInjectable({
   id: "setup-system-theme-type-updater-emitter",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const operatingSystemTheme = di.inject(operatingSystemThemeInjectable);
+    run: () => {
-    const emitSystemThemeTypeUpdate = di.inject(emitSystemThemeTypeUpdateInjectable);
+      const operatingSystemTheme = di.inject(operatingSystemThemeInjectable);
+      const emitSystemThemeTypeUpdate = di.inject(emitSystemThemeTypeUpdateInjectable);
 
-    return {
+      reaction(
-      id: "setup-system-theme-type-updater-emitter",
+        () => operatingSystemTheme.get(),
-      run: () => {
+        emitSystemThemeTypeUpdate,
-        reaction(
+        {
-          () => operatingSystemTheme.get(),
+          fireImmediately: true,
-          emitSystemThemeTypeUpdate,
+        },
-          {
+      );
-            fireImmediately: true,
+    },
-          },
+  }),
-        );
-      },
-    };
-  },
   injectionToken: onLoadOfApplicationInjectionToken,
 });
 

packages/core/src/features/theme/system-type/renderer/initialize.injectable.ts

@@ -11,14 +11,13 @@ import requestInitialSystemThemeTypeInjectable from "./request-initial.injectabl
 const initializeSystemThemeTypeInjectable = getInjectable({
   id: "initialize-system-theme-type",
   instantiate: (di) => ({
-    id: "initialize-system-theme-type",
     run: async () => {
       const systemThemeConfiguration = di.inject(systemThemeConfigurationInjectable);
       const requestInitialSystemThemeType = di.inject(requestInitialSystemThemeTypeInjectable);
 
       systemThemeConfiguration.set(await requestInitialSystemThemeType());
     },
-    runAfter: di.inject(initUserStoreInjectable),
+    runAfter: initUserStoreInjectable,
   }),
   injectionToken: beforeFrameStartsSecondInjectionToken,
 });

packages/core/src/main/app-paths/setup-app-paths.injectable.ts

@@ -18,38 +18,35 @@ import { appPathsRunnablePhaseInjectionToken } from "../start-main-application/r
 const setupAppPathsInjectable = getInjectable({
   id: "setup-app-paths",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const setElectronAppPath = di.inject(setElectronAppPathInjectable);
+    run: () => {
-    const appName = di.inject(appNameInjectable);
+      const setElectronAppPath = di.inject(setElectronAppPathInjectable);
-    const getElectronAppPath = di.inject(getElectronAppPathInjectable);
+      const appName = di.inject(appNameInjectable);
-    const appPathsState = di.inject(appPathsStateInjectable);
+      const getElectronAppPath = di.inject(getElectronAppPathInjectable);
-    const directoryForIntegrationTesting = di.inject(directoryForIntegrationTestingInjectable);
+      const appPathsState = di.inject(appPathsStateInjectable);
-    const joinPaths = di.inject(joinPathsInjectable);
+      const directoryForIntegrationTesting = di.inject(directoryForIntegrationTestingInjectable);
+      const joinPaths = di.inject(joinPathsInjectable);
 
-    return {
+      if (directoryForIntegrationTesting) {
-      id: "setup-app-paths",
+        setElectronAppPath("appData", directoryForIntegrationTesting);
-      run: () => {
+      }
-        if (directoryForIntegrationTesting) {
-          setElectronAppPath("appData", directoryForIntegrationTesting);
-        }
 
-        const appDataPath = getElectronAppPath("appData");
+      const appDataPath = getElectronAppPath("appData");
 
-        setElectronAppPath("userData", joinPaths(appDataPath, appName));
+      setElectronAppPath("userData", joinPaths(appDataPath, appName));
 
-        const appPaths = pipeline(
+      const appPaths = pipeline(
-          pathNames,
+        pathNames,
-          map(name => [name, getElectronAppPath(name)]),
+        map(name => [name, getElectronAppPath(name)]),
-          fromPairs,
+        fromPairs,
-        ) as AppPaths;
+      ) as AppPaths;
 
-        appPathsState.set(appPaths);
+      appPathsState.set(appPaths);
 
-        // NOTE: this is the worse of two evils. This makes sure that `RunnableSync` always is sync
+      // NOTE: this is the worse of two evils. This makes sure that `RunnableSync` always is sync
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: appPathsRunnablePhaseInjectionToken,
 });

packages/core/src/main/catalog-sync-to-renderer/start-catalog-sync.injectable.ts

@@ -3,24 +3,21 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { afterRootFrameIsReadyInjectionToken } from "../start-main-application/runnable-tokens/after-root-frame-is-ready-injection-token";
+import { afterRootFrameIsReadyInjectionToken } from "../start-main-application/runnable-tokens/phases";
 import catalogSyncToRendererInjectable from "./catalog-sync-to-renderer.injectable";
 
 const startCatalogSyncInjectable = getInjectable({
   id: "start-catalog-sync",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const catalogSyncToRenderer = di.inject(catalogSyncToRendererInjectable);
+    run: () => {
+      const catalogSyncToRenderer = di.inject(catalogSyncToRendererInjectable);
 
-    return {
+      if (!catalogSyncToRenderer.started) {
-      id: "start-catalog-sync",
+        catalogSyncToRenderer.start();
-      run: () => {
+      }
-        if (!catalogSyncToRenderer.started) {
+    },
-          catalogSyncToRenderer.start();
+  }),
-        }
-      },
-    };
-  },
 
   injectionToken: afterRootFrameIsReadyInjectionToken,
 });

packages/core/src/main/catalog-sync-to-renderer/stop-catalog-sync.injectable.ts

@@ -4,25 +4,22 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import catalogSyncToRendererInjectable from "./catalog-sync-to-renderer.injectable";
-import { beforeQuitOfFrontEndInjectionToken } from "../start-main-application/runnable-tokens/before-quit-of-front-end-injection-token";
+import { beforeQuitOfFrontEndInjectionToken } from "../start-main-application/runnable-tokens/phases";
 
 const stopCatalogSyncInjectable = getInjectable({
   id: "stop-catalog-sync",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const catalogSyncToRenderer = di.inject(catalogSyncToRendererInjectable);
+    run: () => {
+      const catalogSyncToRenderer = di.inject(catalogSyncToRendererInjectable);
 
-    return {
+      if (catalogSyncToRenderer.started) {
-      id: "stop-catalog-sync",
+        catalogSyncToRenderer.stop();
-      run: () => {
+      }
-        if (catalogSyncToRenderer.started) {
-          catalogSyncToRenderer.stop();
-        }
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeQuitOfFrontEndInjectionToken,
 });

packages/core/src/main/cluster/initialize-manager.injectable.ts

@@ -3,21 +3,18 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { onLoadOfApplicationInjectionToken } from "../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../start-main-application/runnable-tokens/phases";
 import clusterManagerInjectable from "./manager.injectable";
 
 const initializeClusterManagerInjectable = getInjectable({
   id: "initialize-cluster-manager",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const clusterManager = di.inject(clusterManagerInjectable);
+    run: () => {
+      const clusterManager = di.inject(clusterManagerInjectable);
 
-    return {
+      clusterManager.init();
-      id: "initialize-cluster-manager",
+    },
-      run: () => {
+  }),
-        clusterManager.init();
-      },
-    };
-  },
   injectionToken: onLoadOfApplicationInjectionToken,
   causesSideEffects: true,
 });

packages/core/src/main/electron-app/runnables/clean-up-deep-linking.injectable.ts

@@ -3,20 +3,21 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import lensProtocolRouterMainInjectable from "../../protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable";
 
 const cleanUpDeepLinkingInjectable = getInjectable({
   id: "clean-up-deep-linking",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
+    run: () => {
+      const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
 
-    return {
+      lensProtocolRouterMain.cleanup();
-      id: "clean-up-deep-linking",
+
-      run: () => void lensProtocolRouterMain.cleanup(),
+      return undefined;
-    };
+    },
-  },
+  }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/main/electron-app/runnables/dock-visibility/hide-dock-for-last-closed-window.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeQuitOfFrontEndInjectionToken } from "../../../start-main-application/runnable-tokens/before-quit-of-front-end-injection-token";
+import { beforeQuitOfFrontEndInjectionToken } from "../../../start-main-application/runnable-tokens/phases";
 import electronAppInjectable from "../../electron-app.injectable";
 import { isEmpty } from "lodash/fp";
 import getVisibleWindowsInjectable from "../../../start-main-application/lens-window/get-visible-windows.injectable";
@@ -11,23 +11,19 @@ import getVisibleWindowsInjectable from "../../../start-main-application/lens-wi
 const hideDockForLastClosedWindowInjectable = getInjectable({
   id: "hide-dock-when-there-are-no-windows",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const app = di.inject(electronAppInjectable);
+    run: () => {
-    const getVisibleWindows = di.inject(getVisibleWindowsInjectable);
+      const app = di.inject(electronAppInjectable);
+      const getVisibleWindows = di.inject(getVisibleWindowsInjectable);
+      const visibleWindows = getVisibleWindows();
 
-    return {
+      if (isEmpty(visibleWindows)) {
-      id: "hide-dock-when-there-are-no-windows",
+        app.dock?.hide();
-      run: () => {
+      }
-        const visibleWindows = getVisibleWindows();
 
-        if (isEmpty(visibleWindows)) {
+      return undefined;
-          app.dock?.hide();
+    },
-        }
+  }),
-
-        return undefined;
-      },
-    };
-  },
 
   injectionToken: beforeQuitOfFrontEndInjectionToken,
 });

packages/core/src/main/electron-app/runnables/dock-visibility/show-dock-for-first-opened-window.injectable.ts

@@ -4,21 +4,18 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import electronAppInjectable from "../../electron-app.injectable";
-import { afterWindowIsOpenedInjectionToken } from "../../../start-main-application/runnable-tokens/after-window-is-opened-injection-token";
+import { afterWindowIsOpenedInjectionToken } from "../../../start-main-application/runnable-tokens/phases";
 
 const showDockForFirstOpenedWindowInjectable = getInjectable({
   id: "show-dock-for-first-opened-window",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const app = di.inject(electronAppInjectable);
+    run: () => {
+      const app = di.inject(electronAppInjectable);
 
-    return {
+      app.dock?.show();
-      id: "show-dock-for-first-opened-window",
+    },
-      run: () => {
+  }),
-        app.dock?.show();
-      },
-    };
-  },
 
   injectionToken: afterWindowIsOpenedInjectionToken,
 });

packages/core/src/main/electron-app/runnables/enforce-single-application-instance.injectable.ts

@@ -3,28 +3,25 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeElectronIsReadyInjectionToken } from "../../start-main-application/runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import requestSingleInstanceLockInjectable from "../features/request-single-instance-lock.injectable";
 import exitAppInjectable from "../features/exit-app.injectable";
 
 const enforceSingleApplicationInstanceInjectable = getInjectable({
   id: "enforce-single-application-instance",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const requestSingleInstanceLock = di.inject(requestSingleInstanceLockInjectable);
+    run: () => {
-    const exitApp = di.inject(exitAppInjectable);
+      const requestSingleInstanceLock = di.inject(requestSingleInstanceLockInjectable);
+      const exitApp = di.inject(exitAppInjectable);
 
-    return {
+      if (!requestSingleInstanceLock()) {
-      id: "enforce-single-application-instance",
+        exitApp();
-      run: () => {
+      }
-        if (!requestSingleInstanceLock()) {
-          exitApp();
-        }
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeElectronIsReadyInjectionToken,
 });

packages/core/src/main/electron-app/runnables/setup-application-name.injectable.ts

@@ -4,25 +4,22 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import appNameInjectable from "../../../common/vars/app-name.injectable";
-import { beforeElectronIsReadyInjectionToken } from "../../start-main-application/runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import electronAppInjectable from "../electron-app.injectable";
 
 const setupApplicationNameInjectable = getInjectable({
   id: "setup-application-name",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const app = di.inject(electronAppInjectable);
+    run: () => {
-    const appName = di.inject(appNameInjectable);
+      const app = di.inject(electronAppInjectable);
+      const appName = di.inject(appNameInjectable);
 
-    return {
+      app.setName(appName);
-      id: "setup-application-name",
-      run: () => {
-        app.setName(appName);
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeElectronIsReadyInjectionToken,
 });

packages/core/src/main/electron-app/runnables/setup-deep-linking.injectable.ts

@@ -7,68 +7,63 @@ import electronAppInjectable from "../electron-app.injectable";
 import openDeepLinkInjectable from "../../protocol-handler/lens-protocol-router-main/open-deep-link-for-url/open-deep-link.injectable";
 import loggerInjectable from "../../../common/logger.injectable";
 import commandLineArgumentsInjectable from "../../utils/command-line-arguments.injectable";
-import { pipeline } from "@ogre-tools/fp";
+import { startsWith, toLower } from "lodash/fp";
-import { find, startsWith, toLower, map } from "lodash/fp";
+import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/phases";
-import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
 import showApplicationWindowInjectable from "../../start-main-application/lens-window/show-application-window.injectable";
 
 const setupDeepLinkingInjectable = getInjectable({
   id: "setup-deep-linking",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const app = di.inject(electronAppInjectable);
+    run: async () => {
-    const logger = di.inject(loggerInjectable);
+      const app = di.inject(electronAppInjectable);
-    const openDeepLinkForUrl = di.inject(openDeepLinkInjectable);
+      const logger = di.inject(loggerInjectable);
-    const showApplicationWindow = di.inject(showApplicationWindowInjectable);
+      const openDeepLinkForUrl = di.inject(openDeepLinkInjectable);
+      const showApplicationWindow = di.inject(showApplicationWindowInjectable);
+      const firstInstanceCommandLineArguments = di.inject(commandLineArgumentsInjectable);
 
-    const firstInstanceCommandLineArguments = di.inject(
+      logger.info(`📟 Setting protocol client for lens://`);
-      commandLineArgumentsInjectable,
-    );
 
-    return {
+      if (app.setAsDefaultProtocolClient("lens")) {
-      id: "setup-deep-linking",
+        logger.info("📟 Protocol client register succeeded ✅");
-      run: async () => {
+      } else {
-        logger.info(`📟 Setting protocol client for lens://`);
+        logger.info("📟 Protocol client register failed ❗");
+      }
 
-        if (app.setAsDefaultProtocolClient("lens")) {
+      const url = getDeepLinkUrl(firstInstanceCommandLineArguments);
-          logger.info("📟 Protocol client register succeeded ✅");
-        } else {
-          logger.info("📟 Protocol client register failed ❗");
-        }
 
-        const url = getDeepLinkUrl(firstInstanceCommandLineArguments);
+      if (url) {
+        await openDeepLinkForUrl(url);
+      }
 
-        if (url) {
+      app.on("open-url", async (event, url) => {
-          await openDeepLinkForUrl(url);
+        event.preventDefault();
-        }
 
-        app.on("open-url", async (event, url) => {
+        await openDeepLinkForUrl(url);
-          event.preventDefault();
+      });
 
-          await openDeepLinkForUrl(url);
+      app.on(
-        });
+        "second-instance",
+        async (_, secondInstanceCommandLineArguments) => {
+          const url = getDeepLinkUrl(secondInstanceCommandLineArguments);
 
-        app.on(
+          await showApplicationWindow();
-          "second-instance",
 
-          async (_, secondInstanceCommandLineArguments) => {
+          if (url) {
-            const url = getDeepLinkUrl(secondInstanceCommandLineArguments);
+            await openDeepLinkForUrl(url);
-
+          }
-            await showApplicationWindow();
+        },
-
+      );
-            if (url) {
+    },
-              await openDeepLinkForUrl(url);
+  }),
-            }
-          },
-        );
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });
 
 export default setupDeepLinkingInjectable;
 
-const getDeepLinkUrl = (commandLineArguments: string[]) =>
+const getDeepLinkUrl = (commandLineArguments: string[]) => (
-  pipeline(commandLineArguments, map(toLower), find(startsWith("lens://")));
+  commandLineArguments
+    .map(toLower)
+    .find(startsWith("lens://"))
+);

packages/core/src/main/electron-app/runnables/setup-developer-tools-in-development-environment.injectable.ts

@@ -5,37 +5,38 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import nodeEnvInjectionToken from "../../../common/vars/node-env-injection-token";
 import loggerInjectable from "../../../common/logger.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 
 const setupDeveloperToolsInDevelopmentEnvironmentInjectable = getInjectable({
   id: "setup-developer-tools-in-development-environment",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const logger = di.inject(loggerInjectable);
+    run: () => {
-    const nodeEnv = di.inject(nodeEnvInjectionToken);
+      const logger = di.inject(loggerInjectable);
+      const nodeEnv = di.inject(nodeEnvInjectionToken);
 
-    return {
+      if (nodeEnv !== "development") {
-      id: "setup-developer-tools-in-development-environment",
+        return;
-      run: () => {
+      }
-        if (nodeEnv !== "development") {
+
-          return;
+      logger.info("🤓 Installing developer tools");
+
+      void (async () => {
+        try {
+          const {
+            default: devToolsInstaller,
+            REACT_DEVELOPER_TOOLS,
+          } = await import("electron-devtools-installer");
+
+          const name = await devToolsInstaller([REACT_DEVELOPER_TOOLS]);
+
+          logger.info(`[DEVTOOLS-INSTALLER]: installed ${name}`);
+        } catch (error) {
+          logger.error(`[DEVTOOLS-INSTALLER]: failed`, { error });
         }
-
+      })();
-        logger.info("🤓 Installing developer tools");
+    },
-
+  }),
-        import("electron-devtools-installer")
-          .then(({ default: devToolsInstaller, REACT_DEVELOPER_TOOLS }) =>
-            devToolsInstaller([REACT_DEVELOPER_TOOLS]),
-          )
-          .then((name) =>
-            logger.info(`[DEVTOOLS-INSTALLER]: installed ${name}`),
-          )
-          .catch((error) =>
-            logger.error(`[DEVTOOLS-INSTALLER]: failed`, { error }),
-          );
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/electron-app/runnables/setup-device-shutdown.injectable.ts

@@ -5,24 +5,19 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import powerMonitorInjectable from "../features/power-monitor.injectable";
 import exitAppInjectable from "../features/exit-app.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 
 const setupDeviceShutdownInjectable = getInjectable({
   id: "setup-device-shutdown",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const powerMonitor = di.inject(powerMonitorInjectable);
+    run: () => {
-    const exitApp = di.inject(exitAppInjectable);
+      const powerMonitor = di.inject(powerMonitorInjectable);
+      const exitApp = di.inject(exitAppInjectable);
 
-    return {
+      powerMonitor.on("shutdown", exitApp);
-      id: "setup-device-shutdown",
+    },
-      run: () => {
+  }),
-        powerMonitor.on("shutdown", async () => {
-          exitApp();
-        });
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/electron-app/runnables/setup-ipc-main-handlers/setup-ipc-main-handlers.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { setupIpcMainHandlers } from "./setup-ipc-main-handlers";
 import loggerInjectable from "../../../../common/logger.injectable";
 import clusterStoreInjectable from "../../../../common/cluster-store/cluster-store.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../../start-main-application/runnable-tokens/phases";
 import applicationMenuItemCompositeInjectable from "../../../../features/application-menu/main/application-menu-item-composite.injectable";
 import emitAppEventInjectable from "../../../../common/app-event-bus/emit-event.injectable";
 import getClusterByIdInjectable from "../../../../common/cluster-store/get-by-id.injectable";
@@ -15,29 +15,26 @@ import pushCatalogToRendererInjectable from "../../../catalog-sync-to-renderer/p
 const setupIpcMainHandlersInjectable = getInjectable({
   id: "setup-ipc-main-handlers",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const logger = di.inject(loggerInjectable);
+    run: () => {
-    const applicationMenuItemComposite = di.inject(applicationMenuItemCompositeInjectable);
+      const logger = di.inject(loggerInjectable);
-    const pushCatalogToRenderer = di.inject(pushCatalogToRendererInjectable);
+      const applicationMenuItemComposite = di.inject(applicationMenuItemCompositeInjectable);
-    const clusterStore = di.inject(clusterStoreInjectable);
+      const pushCatalogToRenderer = di.inject(pushCatalogToRendererInjectable);
-    const emitAppEvent = di.inject(emitAppEventInjectable);
+      const clusterStore = di.inject(clusterStoreInjectable);
-    const getClusterById = di.inject(getClusterByIdInjectable);
+      const emitAppEvent = di.inject(emitAppEventInjectable);
+      const getClusterById = di.inject(getClusterByIdInjectable);
 
-    return {
+      logger.debug("[APP-MAIN] initializing ipc main handlers");
-      id: "setup-ipc-main-handlers",
-      run: () => {
-        logger.debug("[APP-MAIN] initializing ipc main handlers");
 
-        setupIpcMainHandlers({
+      setupIpcMainHandlers({
-          applicationMenuItemComposite,
+        applicationMenuItemComposite,
-          pushCatalogToRenderer,
+        pushCatalogToRenderer,
-          clusterStore,
+        clusterStore,
-          emitAppEvent,
+        emitAppEvent,
-          getClusterById,
+        getClusterById,
-        });
+      });
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
   causesSideEffects: true,

packages/core/src/main/electron-app/runnables/setup-main-window-visibility-after-activation.injectable.ts

@@ -5,30 +5,27 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import electronAppInjectable from "../electron-app.injectable";
 import loggerInjectable from "../../../common/logger.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import showApplicationWindowInjectable from "../../start-main-application/lens-window/show-application-window.injectable";
 
 const setupMainWindowVisibilityAfterActivationInjectable = getInjectable({
   id: "setup-main-window-visibility-after-activation",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const app = di.inject(electronAppInjectable);
+    run: () => {
-    const showApplicationWindow = di.inject(showApplicationWindowInjectable);
+      const app = di.inject(electronAppInjectable);
-    const logger = di.inject(loggerInjectable);
+      const showApplicationWindow = di.inject(showApplicationWindowInjectable);
+      const logger = di.inject(loggerInjectable);
 
-    return {
+      app.on("activate", (_, windowIsVisible) => {
-      id: "setup-main-window-visibility-after-activation",
+        logger.info("APP:ACTIVATE", { hasVisibleWindows: windowIsVisible });
-      run: () => {
-        app.on("activate", async (_, windowIsVisible) => {
-          logger.info("APP:ACTIVATE", { hasVisibleWindows: windowIsVisible });
 
-          if (!windowIsVisible) {
+        if (!windowIsVisible) {
-            await showApplicationWindow();
+          void showApplicationWindow();
-          }
+        }
-        });
+      });
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/electron-app/runnables/setup-runnables-after-window-is-opened.injectable.ts

@@ -3,29 +3,25 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeElectronIsReadyInjectionToken } from "../../start-main-application/runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken, afterWindowIsOpenedInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import electronAppInjectable from "../electron-app.injectable";
 import { runManyFor } from "../../../common/runnable/run-many-for";
-import { afterWindowIsOpenedInjectionToken } from "../../start-main-application/runnable-tokens/after-window-is-opened-injection-token";
 
 const setupRunnablesAfterWindowIsOpenedInjectable = getInjectable({
   id: "setup-runnables-after-window-is-opened",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const afterWindowIsOpened = runManyFor(di)(afterWindowIsOpenedInjectionToken);
+    run: () => {
-    const app = di.inject(electronAppInjectable);
+      const afterWindowIsOpened = runManyFor(di)(afterWindowIsOpenedInjectionToken);
+      const app = di.inject(electronAppInjectable);
 
-    return {
+      app.on("browser-window-created", () => {
-      id: "setup-runnables-after-window-is-opened",
+        afterWindowIsOpened();
-      run: () => {
+      });
-        app.on("browser-window-created", () => {
-          afterWindowIsOpened();
-        });
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeElectronIsReadyInjectionToken,
 });

packages/core/src/main/electron-app/runnables/setup-runnables-before-closing-of-application.injectable.ts

@@ -3,9 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeElectronIsReadyInjectionToken } from "../../start-main-application/runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken, beforeQuitOfFrontEndInjectionToken, beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/phases";
-import { beforeQuitOfFrontEndInjectionToken } from "../../start-main-application/runnable-tokens/before-quit-of-front-end-injection-token";
-import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
 import electronAppInjectable from "../electron-app.injectable";
 import isIntegrationTestingInjectable from "../../../common/vars/is-integration-testing.injectable";
 import autoUpdaterInjectable from "../features/auto-updater.injectable";
@@ -14,40 +12,36 @@ import { runManySyncFor } from "../../../common/runnable/run-many-sync-for";
 const setupRunnablesBeforeClosingOfApplicationInjectable = getInjectable({
   id: "setup-closing-of-application",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const runManySync = runManySyncFor(di);
+    run: () => {
-    const runRunnablesBeforeQuitOfFrontEnd = runManySync(beforeQuitOfFrontEndInjectionToken);
+      const runManySync = runManySyncFor(di);
-    const runRunnablesBeforeQuitOfBackEnd = runManySync(beforeQuitOfBackEndInjectionToken);
+      const runRunnablesBeforeQuitOfFrontEnd = runManySync(beforeQuitOfFrontEndInjectionToken);
-    const app = di.inject(electronAppInjectable);
+      const runRunnablesBeforeQuitOfBackEnd = runManySync(beforeQuitOfBackEndInjectionToken);
-    const isIntegrationTesting = di.inject(isIntegrationTestingInjectable);
+      const app = di.inject(electronAppInjectable);
-    const autoUpdater = di.inject(autoUpdaterInjectable);
+      const isIntegrationTesting = di.inject(isIntegrationTestingInjectable);
+      const autoUpdater = di.inject(autoUpdaterInjectable);
+      let isAutoUpdating = false;
 
-    return {
+      autoUpdater.on("before-quit-for-update", () => {
-      id: "setup-closing-of-application",
+        isAutoUpdating = true;
-      run: () => {
+      });
-        let isAutoUpdating = false;
 
-        autoUpdater.on("before-quit-for-update", () => {
+      app.on("will-quit", (event) => {
-          isAutoUpdating = true;
+        runRunnablesBeforeQuitOfFrontEnd();
-        });
 
-        app.on("will-quit", (event) => {
+        const shouldQuitBackEnd = isIntegrationTesting || isAutoUpdating;
-          runRunnablesBeforeQuitOfFrontEnd();
 
-          const shouldQuitBackEnd = isIntegrationTesting || isAutoUpdating;
+        if (shouldQuitBackEnd) {
+          runRunnablesBeforeQuitOfBackEnd();
+        } else {
+          // IMPORTANT: This cannot be destructured as it would break binding of "this" for the Electron event
+          event.preventDefault();
+        }
+      });
 
-          if (shouldQuitBackEnd) {
+      return undefined;
-            runRunnablesBeforeQuitOfBackEnd();
+    },
-          } else {
+  }),
-            // IMPORTANT: This cannot be destructured as it would break binding of "this" for the Electron event
-            event.preventDefault();
-          }
-        });
-
-        return undefined;
-      },
-    };
-  },
 
   injectionToken: beforeElectronIsReadyInjectionToken,
 });

packages/core/src/main/library.ts

@@ -4,10 +4,12 @@
  */
 
 // @experimental
-export { afterApplicationIsLoadedInjectionToken } from "./start-main-application/runnable-tokens/after-application-is-loaded-injection-token";
+export {
-export { beforeApplicationIsLoadingInjectionToken } from "./start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+  afterApplicationIsLoadedInjectionToken,
-export { beforeElectronIsReadyInjectionToken } from "./start-main-application/runnable-tokens/before-electron-is-ready-injection-token";
+  beforeApplicationIsLoadingInjectionToken,
-export { onLoadOfApplicationInjectionToken } from "./start-main-application/runnable-tokens/on-load-of-application-injection-token";
+  beforeElectronIsReadyInjectionToken,
+  onLoadOfApplicationInjectionToken,
+} from "./start-main-application/runnable-tokens/phases";
 export { createApplication } from "./create-app";
 export type { CreateApplication, Application, ApplicationConfig } from "../common/create-app";
 export * as Mobx from "mobx";

packages/core/src/main/start-main-application/lens-window/get-visible-windows.injectable.ts

@@ -2,23 +2,16 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { pipeline } from "@ogre-tools/fp";
 import { getInjectable } from "@ogre-tools/injectable";
-import { filter } from "lodash/fp";
 import { applicationWindowInjectionToken } from "./application-window/application-window-injection-token";
 
 const getVisibleWindowsInjectable = getInjectable({
   id: "get-visible-windows",
 
-  instantiate: (di) => {
+  instantiate: (di) => () => (
-    const getAllLensWindows = () => di.injectMany(applicationWindowInjectionToken);
+    di.injectMany(applicationWindowInjectionToken)
-
+      .filter(window => window.isVisible)
-    return () =>
+  ),
-      pipeline(
-        getAllLensWindows(),
-        filter((lensWindow) => !!lensWindow.isVisible),
-      );
-  },
 });
 
 export default getVisibleWindowsInjectable;

packages/core/src/main/start-main-application/runnable-tokens/after-application-is-loaded-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../../../common/runnable/run-many-for";
-
-export const afterApplicationIsLoadedInjectionToken = getInjectionToken<Runnable>({
-  id: "after-application-is-loaded",
-});

packages/core/src/main/start-main-application/runnable-tokens/after-root-frame-is-ready-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../../../common/runnable/run-many-for";
-
-export const afterRootFrameIsReadyInjectionToken = getInjectionToken<Runnable>({
-  id: "after-root-frame-is-ready",
-});

packages/core/src/main/start-main-application/runnable-tokens/after-window-is-opened-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../../../common/runnable/run-many-for";
-
-export const afterWindowIsOpenedInjectionToken = getInjectionToken<Runnable>({
-  id: "after-window-is-opened",
-});

packages/core/src/main/start-main-application/runnable-tokens/before-application-is-loading-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../../../common/runnable/run-many-for";
-
-export const beforeApplicationIsLoadingInjectionToken = getInjectionToken<Runnable>({
-  id: "before-application-is-loading",
-});

packages/core/src/main/start-main-application/runnable-tokens/before-electron-is-ready-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { RunnableSync } from "../../../common/runnable/run-many-sync-for";
-
-export const beforeElectronIsReadyInjectionToken = getInjectionToken<RunnableSync>({
-  id: "before-electron-is-ready",
-});

packages/core/src/main/start-main-application/runnable-tokens/before-quit-of-back-end-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { RunnableSync } from "../../../common/runnable/run-many-sync-for";
-
-export const beforeQuitOfBackEndInjectionToken = getInjectionToken<RunnableSync>({
-  id: "before-quit-of-back-end",
-});

packages/core/src/main/start-main-application/runnable-tokens/before-quit-of-front-end-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { RunnableSync } from "../../../common/runnable/run-many-sync-for";
-
-export const beforeQuitOfFrontEndInjectionToken = getInjectionToken<RunnableSync>({
-  id: "before-quit-of-front-end",
-});

packages/core/src/main/start-main-application/runnable-tokens/on-load-of-application-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../../../common/runnable/run-many-for";
-
-export const onLoadOfApplicationInjectionToken = getInjectionToken<Runnable>({
-  id: "on-load-of-application",
-});

packages/core/src/main/start-main-application/runnable-tokens/phases.ts

@@ -4,8 +4,7 @@
  */
 
 import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../../../common/runnable/run-many-for";
+import type { Runnable, RunnableSync } from "../../../common/runnable/types";
-import type { RunnableSync } from "../../../common/runnable/run-many-sync-for";
 
 /**
  * These tokens are here so that the importing of their respective dependencies
@@ -26,3 +25,35 @@ export const showLoadingRunnablePhaseInjectionToken = getInjectionToken<Runnable
 export const showInitialWindowRunnablePhaseInjectionToken = getInjectionToken<Runnable>({
   id: "show-initial-window-runnable-phase",
 });
+
+export const onLoadOfApplicationInjectionToken = getInjectionToken<Runnable>({
+  id: "on-load-of-application",
+});
+
+export const beforeQuitOfFrontEndInjectionToken = getInjectionToken<RunnableSync>({
+  id: "before-quit-of-front-end",
+});
+
+export const beforeQuitOfBackEndInjectionToken = getInjectionToken<RunnableSync>({
+  id: "before-quit-of-back-end",
+});
+
+export const beforeElectronIsReadyInjectionToken = getInjectionToken<RunnableSync>({
+  id: "before-electron-is-ready",
+});
+
+export const beforeApplicationIsLoadingInjectionToken = getInjectionToken<Runnable>({
+  id: "before-application-is-loading",
+});
+
+export const afterWindowIsOpenedInjectionToken = getInjectionToken<Runnable>({
+  id: "after-window-is-opened",
+});
+
+export const afterRootFrameIsReadyInjectionToken = getInjectionToken<Runnable>({
+  id: "after-root-frame-is-ready",
+});
+
+export const afterApplicationIsLoadedInjectionToken = getInjectionToken<Runnable>({
+  id: "after-application-is-loaded",
+});

packages/core/src/main/start-main-application/runnables/clean-up-shell-sessions.injectable.ts

@@ -3,14 +3,13 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../runnable-tokens/phases";
 import { ShellSession } from "../../shell-session/shell-session";
 
 const cleanUpShellSessionsInjectable = getInjectable({
   id: "clean-up-shell-sessions",
 
   instantiate: () => ({
-    id: "clean-up-shell-sessions",
     run: () => void ShellSession.cleanup(),
   }),
 

packages/core/src/main/start-main-application/runnables/emit-close-to-event-bus.injectable.ts

@@ -4,23 +4,20 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import emitAppEventInjectable from "../../../common/app-event-bus/emit-event.injectable";
-import { beforeQuitOfFrontEndInjectionToken } from "../runnable-tokens/before-quit-of-front-end-injection-token";
+import { beforeQuitOfFrontEndInjectionToken } from "../runnable-tokens/phases";
 
 const emitCloseToEventBusInjectable = getInjectable({
   id: "emit-close-to-event-bus",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const emitAppEvent = di.inject(emitAppEventInjectable);
+    run: () => {
+      const emitAppEvent = di.inject(emitAppEventInjectable);
 
-    return {
+      emitAppEvent({ name: "app", action: "close" });
-      id: "emit-close-to-event-bus",
-      run: () => {
-        emitAppEvent({ name: "app", action: "close" });
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeQuitOfFrontEndInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/emit-service-start-to-event-bus.injectable.ts

@@ -4,21 +4,18 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import emitAppEventInjectable from "../../../common/app-event-bus/emit-event.injectable";
-import { afterApplicationIsLoadedInjectionToken } from "../runnable-tokens/after-application-is-loaded-injection-token";
+import { afterApplicationIsLoadedInjectionToken } from "../runnable-tokens/phases";
 
 const emitServiceStartToEventBusInjectable = getInjectable({
   id: "emit-service-start-to-event-bus",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const emitAppEvent = di.inject(emitAppEventInjectable);
+    run: () => {
+      const emitAppEvent = di.inject(emitAppEventInjectable);
 
-    return {
+      emitAppEvent({ name: "service", action: "start" });
-      id: "emit-service-start-to-event-bus",
+    },
-      run: () => {
+  }),
-        emitAppEvent({ name: "service", action: "start" });
-      },
-    };
-  },
 
   injectionToken: afterApplicationIsLoadedInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/flag-renderer/flag-renderer-as-loaded.injectable.ts

@@ -3,26 +3,23 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { afterRootFrameIsReadyInjectionToken } from "../../runnable-tokens/after-root-frame-is-ready-injection-token";
+import { afterRootFrameIsReadyInjectionToken } from "../../runnable-tokens/phases";
 import lensProtocolRouterMainInjectable from "../../../protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable";
 import { runInAction } from "mobx";
 
 const flagRendererAsLoadedInjectable = getInjectable({
   id: "flag-renderer-as-loaded",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
+    run: () => {
+      const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
 
-    return {
+      runInAction(() => {
-      id: "flag-renderer-as-loaded",
+        // Todo: remove this kludge which enables out-of-place temporal dependency.
-      run: () => {
+        lensProtocolRouterMain.rendererLoaded = true;
-        runInAction(() => {
+      });
-          // Todo: remove this kludge which enables out-of-place temporal dependency.
+    },
-          lensProtocolRouterMain.rendererLoaded = true;
+  }),
-        });
-      },
-    };
-  },
 
   injectionToken: afterRootFrameIsReadyInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/flag-renderer/flag-renderer-as-not-loaded.injectable.ts

@@ -5,26 +5,23 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { runInAction } from "mobx";
 import lensProtocolRouterMainInjectable  from "../../../protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable";
-import { beforeQuitOfFrontEndInjectionToken } from "../../runnable-tokens/before-quit-of-front-end-injection-token";
+import { beforeQuitOfFrontEndInjectionToken } from "../../runnable-tokens/phases";
 
 const flagRendererAsNotLoadedInjectable = getInjectable({
   id: "stop-deep-linking",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
+    run: () => {
+      const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
 
-    return {
+      runInAction(() => {
-      id: "stop-deep-linking",
+        // Todo: remove this kludge which enables out-of-place temporal dependency.
-      run: () => {
+        lensProtocolRouterMain.rendererLoaded = false;
-        runInAction(() => {
+      });
-          // Todo: remove this kludge which enables out-of-place temporal dependency.
-          lensProtocolRouterMain.rendererLoaded = false;
-        });
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeQuitOfFrontEndInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/initialize-extensions.injectable.ts

@@ -9,56 +9,51 @@ import loggerInjectable from "../../../common/logger.injectable";
 import extensionDiscoveryInjectable from "../../../extensions/extension-discovery/extension-discovery.injectable";
 import extensionLoaderInjectable from "../../../extensions/extension-loader/extension-loader.injectable";
 import showErrorPopupInjectable from "../../electron-app/features/show-error-popup.injectable";
-import { onLoadOfApplicationInjectionToken } from "../runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../runnable-tokens/phases";
 
 const initializeExtensionsInjectable = getInjectable({
   id: "initialize-extensions",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const logger = di.inject(loggerInjectable);
+    run: async () => {
-    const extensionDiscovery = di.inject(extensionDiscoveryInjectable);
+      const logger = di.inject(loggerInjectable);
-    const extensionLoader = di.inject(extensionLoaderInjectable);
+      const extensionDiscovery = di.inject(extensionDiscoveryInjectable);
-    const showErrorPopup = di.inject(showErrorPopupInjectable);
+      const extensionLoader = di.inject(extensionLoaderInjectable);
+      const showErrorPopup = di.inject(showErrorPopupInjectable);
 
-    return {
+      logger.info("🧩 Initializing extensions");
-      id: "initialize-extensions",
-      run: async () => {
-        logger.info("🧩 Initializing extensions");
 
-        await extensionDiscovery.init();
+      await extensionDiscovery.init();
 
-        await extensionLoader.init();
+      await extensionLoader.init();
 
-        try {
+      try {
-          const extensions = await extensionDiscovery.load();
+        const extensions = await extensionDiscovery.load();
 
-          // Start watching after bundled extensions are loaded
+        // Start watching after bundled extensions are loaded
-          extensionDiscovery.watchExtensions();
+        extensionDiscovery.watchExtensions();
 
-          // Subscribe to extensions that are copied or deleted to/from the extensions folder
+        // Subscribe to extensions that are copied or deleted to/from the extensions folder
-          extensionDiscovery.events
+        extensionDiscovery.events
-            .on("add", (extension: InstalledExtension) => {
+          .on("add", (extension: InstalledExtension) => {
-              extensionLoader.addExtension(extension);
+            extensionLoader.addExtension(extension);
-            })
+          })
-            .on("remove", (lensExtensionId: LensExtensionId) => {
+          .on("remove", (lensExtensionId: LensExtensionId) => {
-              extensionLoader.removeExtension(lensExtensionId);
+            extensionLoader.removeExtension(lensExtensionId);
-            });
+          });
 
-          extensionLoader.initExtensions(extensions);
+        extensionLoader.initExtensions(extensions);
-        } catch (error: any) {
+      } catch (error: any) {
-          showErrorPopup(
+        showErrorPopup(
-            "Lens Error",
+          "Lens Error",
-            `Could not load extensions${
+          `Could not load extensions${error?.message ? `: ${error.message}` : ""}`,
-              error?.message ? `: ${error.message}` : ""
+        );
-            }`,
-          );
 
-          console.error(error);
+        console.error(error);
-          console.trace();
+        console.trace();
-        }
+      }
-      },
+    },
-    };
+  }),
-  },
 
   causesSideEffects: true,
 

packages/core/src/main/start-main-application/runnables/kube-config-sync/add-source.injectable.ts

@@ -5,21 +5,18 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import kubeconfigSyncManagerInjectable from "../../../catalog-sources/kubeconfig-sync/manager.injectable";
 import catalogEntityRegistryInjectable from "../../../catalog/entity-registry.injectable";
-import { afterApplicationIsLoadedInjectionToken } from "../../runnable-tokens/after-application-is-loaded-injection-token";
+import { afterApplicationIsLoadedInjectionToken } from "../../runnable-tokens/phases";
 
 const addKubeconfigSyncAsEntitySourceInjectable = getInjectable({
   id: "add-kubeconfig-sync-as-entity-source",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const kubeConfigSyncManager = di.inject(kubeconfigSyncManagerInjectable);
+    run: () => {
-    const entityRegistry = di.inject(catalogEntityRegistryInjectable);
+      const kubeConfigSyncManager = di.inject(kubeconfigSyncManagerInjectable);
+      const entityRegistry = di.inject(catalogEntityRegistryInjectable);
 
-    return {
+      entityRegistry.addComputedSource("kubeconfig-sync", kubeConfigSyncManager.source);
-      id: "add-kubeconfig-sync-as-entity-source",
+    },
-      run: () => {
+  }),
-        entityRegistry.addComputedSource("kubeconfig-sync", kubeConfigSyncManager.source);
-      },
-    };
-  },
   injectionToken: afterApplicationIsLoadedInjectionToken,
 });
 

packages/core/src/main/start-main-application/runnables/kube-config-sync/start-kube-config-sync.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { afterApplicationIsLoadedInjectionToken } from "../../runnable-tokens/after-application-is-loaded-injection-token";
+import { afterApplicationIsLoadedInjectionToken } from "../../runnable-tokens/phases";
 import directoryForKubeConfigsInjectable from "../../../../common/app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
 import ensureDirInjectable from "../../../../common/fs/ensure-dir.injectable";
 import kubeconfigSyncManagerInjectable from "../../../catalog-sources/kubeconfig-sync/manager.injectable";
@@ -12,21 +12,18 @@ import addKubeconfigSyncAsEntitySourceInjectable from "./add-source.injectable";
 const startKubeConfigSyncInjectable = getInjectable({
   id: "start-kubeconfig-sync",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const directoryForKubeConfigs = di.inject(directoryForKubeConfigsInjectable);
+    run: async () => {
-    const kubeConfigSyncManager = di.inject(kubeconfigSyncManagerInjectable);
+      const directoryForKubeConfigs = di.inject(directoryForKubeConfigsInjectable);
-    const ensureDir = di.inject(ensureDirInjectable);
+      const kubeConfigSyncManager = di.inject(kubeconfigSyncManagerInjectable);
+      const ensureDir = di.inject(ensureDirInjectable);
 
-    return {
+      await ensureDir(directoryForKubeConfigs);
-      id: "start-kubeconfig-sync",
-      run: async () => {
-        await ensureDir(directoryForKubeConfigs);
 
-        kubeConfigSyncManager.startSync();
+      kubeConfigSyncManager.startSync();
-      },
+    },
-      runAfter: di.inject(addKubeconfigSyncAsEntitySourceInjectable),
+    runAfter: addKubeconfigSyncAsEntitySourceInjectable,
-    };
+  }),
-  },
 
   injectionToken: afterApplicationIsLoadedInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/kube-config-sync/stop-kube-config-sync.injectable.ts

@@ -3,20 +3,21 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../runnable-tokens/phases";
 import kubeconfigSyncManagerInjectable from "../../../catalog-sources/kubeconfig-sync/manager.injectable";
 
 const stopKubeConfigSyncInjectable = getInjectable({
   id: "stop-kube-config-sync",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const kubeConfigSyncManager = di.inject(kubeconfigSyncManagerInjectable);
+    run: () => {
+      const kubeConfigSyncManager = di.inject(kubeconfigSyncManagerInjectable);
 
-    return {
+      kubeConfigSyncManager.stopSync();
-      id: "stop-kube-config-sync",
+
-      run: () => void kubeConfigSyncManager.stopSync(),
+      return undefined;
-    };
+    },
-  },
+  }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/root-frame-has-rendered/channel-listener.injectable.ts

@@ -5,7 +5,7 @@
 import { getMessageChannelListenerInjectable } from "../../../../common/utils/channel/message-channel-listener-injection-token";
 import { rootFrameHasRenderedChannel } from "../../../../common/root-frame/root-frame-rendered-channel";
 import { runManyFor } from "../../../../common/runnable/run-many-for";
-import { afterRootFrameIsReadyInjectionToken } from "../../runnable-tokens/after-root-frame-is-ready-injection-token";
+import { afterRootFrameIsReadyInjectionToken } from "../../runnable-tokens/phases";
 
 const rootFrameRenderedChannelListenerInjectable = getMessageChannelListenerInjectable({
   id: "action",

packages/core/src/main/start-main-application/runnables/sentry/setup.injectable.ts

@@ -3,21 +3,22 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeElectronIsReadyInjectionToken } from "../../runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../../runnable-tokens/phases";
 import initializeSentryReportingWithInjectable from "../../../../common/error-reporting/initialize-sentry-reporting.injectable";
 import initializeSentryOnMainInjectable from "./initialize-on-main.injectable";
 
 const setupSentryInjectable = getInjectable({
   id: "setup-sentry",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const initializeSentryReportingWith = di.inject(initializeSentryReportingWithInjectable);
+    run: () => {
-    const initializeSentryOnMain = di.inject(initializeSentryOnMainInjectable);
+      const initializeSentryReportingWith = di.inject(initializeSentryReportingWithInjectable);
+      const initializeSentryOnMain = di.inject(initializeSentryOnMainInjectable);
 
-    return {
+      initializeSentryReportingWith(initializeSentryOnMain);
-      id: "setup-sentry",
+
-      run: () => void initializeSentryReportingWith(initializeSentryOnMain),
+      return undefined;
-    };
+    },
-  },
+  }),
   injectionToken: beforeElectronIsReadyInjectionToken,
 });
 

packages/core/src/main/start-main-application/runnables/setup-hardware-acceleration.injectable.ts

@@ -5,26 +5,23 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import disableHardwareAccelerationInjectable from "../../electron-app/features/disable-hardware-acceleration.injectable";
 import hardwareAccelerationShouldBeDisabledInjectable from "../../vars/hardware-acceleration-should-be-disabled.injectable";
-import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/phases";
 
 const setupHardwareAccelerationInjectable = getInjectable({
   id: "setup-hardware-acceleration",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const hardwareAccelerationShouldBeDisabled = di.inject(hardwareAccelerationShouldBeDisabledInjectable);
+    run: () => {
-    const disableHardwareAcceleration = di.inject(disableHardwareAccelerationInjectable);
+      const hardwareAccelerationShouldBeDisabled = di.inject(hardwareAccelerationShouldBeDisabledInjectable);
+      const disableHardwareAcceleration = di.inject(disableHardwareAccelerationInjectable);
 
-    return {
+      if (hardwareAccelerationShouldBeDisabled) {
-      id: "setup-hardware-acceleration",
+        disableHardwareAcceleration();
-      run: () => {
+      }
-        if (hardwareAccelerationShouldBeDisabled) {
-          disableHardwareAcceleration();
-        }
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeElectronIsReadyInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/setup-hostnames.injectable.ts

@@ -4,27 +4,24 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import electronAppInjectable from "../../electron-app/electron-app.injectable";
-import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/phases";
 
 const setupHostnamesInjectable = getInjectable({
   id: "setup-hostnames",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const app = di.inject(electronAppInjectable);
+    run: () => {
+      const app = di.inject(electronAppInjectable);
 
-    return {
+      app.commandLine.appendSwitch("host-rules", [
-      id: "setup-hostnames",
+        "MAP localhost 127.0.0.1",
-      run: () => {
+        "MAP lens.app 127.0.0.1",
-        app.commandLine.appendSwitch("host-rules", [
+        "MAP *.lens.app 127.0.0.1",
-          "MAP localhost 127.0.0.1",
+      ].join());
-          "MAP lens.app 127.0.0.1",
-          "MAP *.lens.app 127.0.0.1",
-        ].join());
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeElectronIsReadyInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/setup-immer.injectable.ts

@@ -3,19 +3,18 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import * as Immer from "immer";
+import { setAutoFreeze, enableMapSet } from "immer";
-import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/phases";
 
 const setupImmerInjectable = getInjectable({
   id: "setup-immer",
 
   instantiate: () => ({
-    id: "setup-immer",
     run: () => {
       // Docs: https://immerjs.github.io/immer/
       // Required in `utils/storage-helper.ts`
-      Immer.setAutoFreeze(false); // allow to merge mobx observables
+      setAutoFreeze(false); // allow to merge mobx observables
-      Immer.enableMapSet(); // allow to merge maps and sets
+      enableMapSet(); // allow to merge maps and sets
 
       return undefined;
     },

packages/core/src/main/start-main-application/runnables/setup-lens-proxy-certificate.injectable.ts

@@ -5,47 +5,44 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { generate } from "selfsigned";
 import lensProxyCertificateInjectable from "../../../common/certificate/lens-proxy-certificate.injectable";
-import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/phases";
 
 const setupLensProxyCertificateInjectable = getInjectable({
   id: "setup-lens-proxy-certificate",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const lensProxyCertificate = di.inject(lensProxyCertificateInjectable);
+    run: () => {
+      const lensProxyCertificate = di.inject(lensProxyCertificateInjectable);
 
-    return {
+      const cert = generate([
-      id: "setup-lens-proxy-certificate",
+        { name: "commonName", value: "Lens Certificate Authority" },
-      run: () => {
+        { name: "organizationName", value: "Lens" },
-        const cert = generate([
+      ], {
-          { name: "commonName", value: "Lens Certificate Authority" },
+        keySize: 2048,
-          { name: "organizationName", value: "Lens" },
+        algorithm: "sha256",
-        ], {
+        days: 365,
-          keySize: 2048,
+        extensions: [
-          algorithm: "sha256",
+          {
-          days: 365,
+            name: "basicConstraints",
-          extensions: [
+            cA: true,
-            {
+          },
-              name: "basicConstraints",
+          {
-              cA: true,
+            name: "subjectAltName",
-            },
+            altNames: [
-            {
+              { type: 2, value: "*.lens.app" },
-              name: "subjectAltName",
+              { type: 2, value: "lens.app" },
-              altNames: [
+              { type: 2, value: "localhost" },
-                { type: 2, value: "*.lens.app" },
+              { type: 7, ip: "127.0.0.1" },
-                { type: 2, value: "lens.app" },
+            ],
-                { type: 2, value: "localhost" },
+          },
-                { type: 7, ip: "127.0.0.1" },
+        ],
-              ],
+      });
-            },
-          ],
-        });
 
-        lensProxyCertificate.set(cert);
+      lensProxyCertificate.set(cert);
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeElectronIsReadyInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/setup-lens-proxy.injectable.ts

@@ -9,7 +9,7 @@ import loggerInjectable from "../../../common/logger.injectable";
 import lensProxyPortInjectable from "../../lens-proxy/lens-proxy-port.injectable";
 import isWindowsInjectable from "../../../common/vars/is-windows.injectable";
 import showErrorPopupInjectable from "../../electron-app/features/show-error-popup.injectable";
-import { beforeApplicationIsLoadingInjectionToken } from "../runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../runnable-tokens/phases";
 import buildVersionInjectable from "../../vars/build-version/build-version.injectable";
 import initializeBuildVersionInjectable from "../../vars/build-version/init.injectable";
 import lensProxyCertificateInjectable from "../../../common/certificate/lens-proxy-certificate.injectable";
@@ -19,68 +19,65 @@ import { Agent } from "https";
 const setupLensProxyInjectable = getInjectable({
   id: "setup-lens-proxy",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const lensProxy = di.inject(lensProxyInjectable);
+    run: async () => {
-    const exitApp = di.inject(exitAppInjectable);
+      const lensProxy = di.inject(lensProxyInjectable);
-    const logger = di.inject(loggerInjectable);
+      const exitApp = di.inject(exitAppInjectable);
-    const lensProxyPort = di.inject(lensProxyPortInjectable);
+      const logger = di.inject(loggerInjectable);
-    const isWindows = di.inject(isWindowsInjectable);
+      const lensProxyPort = di.inject(lensProxyPortInjectable);
-    const showErrorPopup = di.inject(showErrorPopupInjectable);
+      const isWindows = di.inject(isWindowsInjectable);
-    const buildVersion = di.inject(buildVersionInjectable);
+      const showErrorPopup = di.inject(showErrorPopupInjectable);
-    const lensProxyCertificate = di.inject(lensProxyCertificateInjectable);
+      const buildVersion = di.inject(buildVersionInjectable);
-    const fetch = di.inject(fetchInjectable);
+      const lensProxyCertificate = di.inject(lensProxyCertificateInjectable);
+      const fetch = di.inject(fetchInjectable);
 
-    return {
+      try {
-      id: "setup-lens-proxy",
+        logger.info("🔌 Starting LensProxy");
-      run: async () => {
+        await lensProxy.listen(); // lensProxy.port available
-        try {
+      } catch (error: any) {
-          logger.info("🔌 Starting LensProxy");
+        showErrorPopup("Lens Error", `Could not start proxy: ${error?.message || "unknown error"}`);
-          await lensProxy.listen(); // lensProxy.port available
+
-        } catch (error: any) {
+        return exitApp();
-          showErrorPopup("Lens Error", `Could not start proxy: ${error?.message || "unknown error"}`);
+      }
+
+      // test proxy connection
+      try {
+        logger.info("🔎 Testing LensProxy connection ...");
+        const versionResponse = await fetch(`https://127.0.0.1:${lensProxyPort.get()}/version`, {
+          agent: new Agent({
+            ca: lensProxyCertificate.get()?.cert,
+          }),
+        });
+
+        const { version: versionFromProxy } = await versionResponse.json() as { version: string };
+
+        if (buildVersion.get() !== versionFromProxy) {
+          logger.error("Proxy server responded with invalid response");
 
           return exitApp();
         }
 
-        // test proxy connection
+        logger.info("⚡ LensProxy connection OK");
-        try {
+      } catch (error) {
-          logger.info("🔎 Testing LensProxy connection ...");
+        logger.error(`🛑 LensProxy: failed connection test: ${error}`);
-          const versionResponse = await fetch(`https://127.0.0.1:${lensProxyPort.get()}/version`, {
-            agent: new Agent({
-              ca: lensProxyCertificate.get()?.cert,
-            }),
-          });
 
-          const { version: versionFromProxy } = await versionResponse.json() as { version: string };
+        const hostsPath = isWindows
+          ? "C:\\windows\\system32\\drivers\\etc\\hosts"
+          : "/etc/hosts";
+        const message = [
+          `Failed connection test: ${error}`,
+          "Check to make sure that no other versions of Lens are running",
+          `Check ${hostsPath} to make sure that it is clean and that the localhost loopback is at the top and set to 127.0.0.1`,
+          "If you have HTTP_PROXY or http_proxy set in your environment, make sure that the localhost and the ipv4 loopback address 127.0.0.1 are added to the NO_PROXY environment variable.",
+        ];
 
-          if (buildVersion.get() !== versionFromProxy) {
+        showErrorPopup("Lens Proxy Error", message.join("\n\n"));
-            logger.error("Proxy server responded with invalid response");
 
-            return exitApp();
+        return exitApp();
-          }
+      }
-
+    },
-          logger.info("⚡ LensProxy connection OK");
+    runAfter: initializeBuildVersionInjectable,
-        } catch (error) {
+  }),
-          logger.error(`🛑 LensProxy: failed connection test: ${error}`);
-
-          const hostsPath = isWindows
-            ? "C:\\windows\\system32\\drivers\\etc\\hosts"
-            : "/etc/hosts";
-          const message = [
-            `Failed connection test: ${error}`,
-            "Check to make sure that no other versions of Lens are running",
-            `Check ${hostsPath} to make sure that it is clean and that the localhost loopback is at the top and set to 127.0.0.1`,
-            "If you have HTTP_PROXY or http_proxy set in your environment, make sure that the localhost and the ipv4 loopback address 127.0.0.1 are added to the NO_PROXY environment variable.",
-          ];
-
-          showErrorPopup("Lens Proxy Error", message.join("\n\n"));
-
-          return exitApp();
-        }
-      },
-      runAfter: di.inject(initializeBuildVersionInjectable),
-    };
-  },
 
   causesSideEffects: true,
 

packages/core/src/main/start-main-application/runnables/setup-mobx.injectable.ts

@@ -4,13 +4,12 @@
  */
 import * as Mobx from "mobx";
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/phases";
 
 const setupMobxInjectable = getInjectable({
   id: "setup-mobx",
 
   instantiate: () => ({
-    id: "setup-mobx",
     run: () => {
       // Docs: https://mobx.js.org/configuration.html
       Mobx.configure({

packages/core/src/main/start-main-application/runnables/setup-proxy-env.injectable.ts

@@ -3,42 +3,37 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/before-electron-is-ready-injection-token";
+import { beforeElectronIsReadyInjectionToken } from "../runnable-tokens/phases";
 import getCommandLineSwitchInjectable from "../../electron-app/features/get-command-line-switch.injectable";
 
 const setupProxyEnvInjectable = getInjectable({
   id: "setup-proxy-env",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const getCommandLineSwitch = di.inject(getCommandLineSwitchInjectable);
+    run: () => {
+      const getCommandLineSwitch = di.inject(getCommandLineSwitchInjectable);
+      const switchValue = getCommandLineSwitch("proxy-server");
 
-    return {
+      let httpsProxy = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || "";
-      id: "setup-proxy-env",
-      run: () => {
-        const switchValue = getCommandLineSwitch("proxy-server");
 
-        let httpsProxy =
+      delete process.env.HTTPS_PROXY;
-          process.env.HTTPS_PROXY || process.env.HTTP_PROXY || "";
+      delete process.env.HTTP_PROXY;
 
-        delete process.env.HTTPS_PROXY;
+      if (switchValue !== "") {
-        delete process.env.HTTP_PROXY;
+        httpsProxy = switchValue;
+      }
 
-        if (switchValue !== "") {
+      if (httpsProxy !== "") {
-          httpsProxy = switchValue;
+        process.env.APP_HTTPS_PROXY = httpsProxy;
-        }
+      }
 
-        if (httpsProxy !== "") {
+      if (getCommandLineSwitch("proxy-server") !== "") {
-          process.env.APP_HTTPS_PROXY = httpsProxy;
+        process.env.HTTPS_PROXY = getCommandLineSwitch("proxy-server");
-        }
+      }
 
-        if (getCommandLineSwitch("proxy-server") !== "") {
+      return undefined;
-          process.env.HTTPS_PROXY = getCommandLineSwitch("proxy-server");
+    },
-        }
+  }),
-
-        return undefined;
-      },
-    };
-  },
 
   injectionToken: beforeElectronIsReadyInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/setup-syncing-of-general-catalog-entities.injectable.ts

@@ -4,23 +4,18 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import syncGeneralCatalogEntitiesInjectable from "../../catalog-sources/sync-general-catalog-entities.injectable";
-import { onLoadOfApplicationInjectionToken } from "../runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../runnable-tokens/phases";
 
 const setupSyncingOfGeneralCatalogEntitiesInjectable = getInjectable({
   id: "setup-syncing-of-general-catalog-entities",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const syncGeneralCatalogEntities = di.inject(
+    run: () => {
-      syncGeneralCatalogEntitiesInjectable,
+      const syncGeneralCatalogEntities = di.inject(syncGeneralCatalogEntitiesInjectable);
-    );
 
-    return {
+      syncGeneralCatalogEntities();
-      id: "setup-syncing-of-general-catalog-entities",
+    },
-      run: () => {
+  }),
-        syncGeneralCatalogEntities();
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/setup-syncing-of-weblinks.injectable.ts

@@ -3,22 +3,19 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { onLoadOfApplicationInjectionToken } from "../runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../runnable-tokens/phases";
 import syncWeblinksInjectable from "../../catalog-sources/sync-weblinks.injectable";
 
 const setupSyncingOfWeblinksInjectable = getInjectable({
   id: "setup-syncing-of-weblinks",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const syncWeblinks = di.inject(syncWeblinksInjectable);
+    run: () => {
+      const syncWeblinks = di.inject(syncWeblinksInjectable);
 
-    return {
+      syncWeblinks();
-      id: "setup-syncing-of-weblinks",
+    },
-      run: () => {
+  }),
-        syncWeblinks();
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/setup-system-ca.injectable.ts

@@ -3,14 +3,17 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeApplicationIsLoadingInjectionToken } from "../runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../runnable-tokens/phases";
 import injectSystemCAsInjectable from "../../../features/certificate-authorities/common/inject-system-cas.injectable";
 
 const setupSystemCaInjectable = getInjectable({
   id: "setup-system-ca",
   instantiate: (di) => ({
-    id: "setup-system-ca",
+    run: async () => {
-    run: di.inject(injectSystemCAsInjectable),
+      const injectSystemCAs = di.inject(injectSystemCAsInjectable);
+
+      await injectSystemCAs();
+    },
   }),
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });

packages/core/src/main/start-main-application/runnables/show-initial-window.injectable.ts

@@ -18,33 +18,30 @@ const getDeepLinkUrl = (commandLineArguments: string[]) => (
 
 const showInitialWindowInjectable = getInjectable({
   id: "show-initial-window",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const shouldStartHidden = di.inject(shouldStartHiddenInjectable);
+    run: async () => {
-    const shouldStartWindow = !shouldStartHidden;
+      const shouldStartHidden = di.inject(shouldStartHiddenInjectable);
-    const createFirstApplicationWindow = di.inject(createFirstApplicationWindowInjectable);
+      const shouldStartWindow = !shouldStartHidden;
-    const splashWindow = di.inject(splashWindowInjectable);
+      const createFirstApplicationWindow = di.inject(createFirstApplicationWindowInjectable);
-    const openDeepLink = di.inject(openDeepLinkInjectable);
+      const splashWindow = di.inject(splashWindowInjectable);
-    const commandLineArguments = di.inject(commandLineArgumentsInjectable);
+      const openDeepLink = di.inject(openDeepLinkInjectable);
+      const commandLineArguments = di.inject(commandLineArgumentsInjectable);
 
-    return {
+      if (shouldStartWindow) {
-      id: "show-initial-window",
+        const deepLinkUrl = getDeepLinkUrl(commandLineArguments);
-      run: async () => {
-        if (shouldStartWindow) {
-          const deepLinkUrl = getDeepLinkUrl(commandLineArguments);
 
-          if (deepLinkUrl) {
+        if (deepLinkUrl) {
-            await openDeepLink(deepLinkUrl);
+          await openDeepLink(deepLinkUrl);
-          } else {
+        } else {
-            const applicationWindow = createFirstApplicationWindow();
+          const applicationWindow = createFirstApplicationWindow();
 
-            await applicationWindow.start();
+          await applicationWindow.start();
-          }
-
-          splashWindow.close();
         }
-      },
+
-    };
+        splashWindow.close();
-  },
+      }
+    },
+  }),
   injectionToken: showInitialWindowRunnablePhaseInjectionToken,
 });
 

packages/core/src/main/start-main-application/runnables/show-loading.injectable.ts

@@ -9,20 +9,18 @@ import { showLoadingRunnablePhaseInjectionToken } from "../runnable-tokens/phase
 
 const showLoadingInjectable = getInjectable({
   id: "show-loading",
-  instantiate: (di) => {
-    const shouldStartHidden = di.inject(shouldStartHiddenInjectable);
-    const shouldShowLoadingWindow = !shouldStartHidden;
-    const splashWindow = di.inject(splashWindowInjectable);
 
-    return {
+  instantiate: (di) => ({
-      id: "show-loading",
+    run: async () => {
-      run: async () => {
+      const shouldStartHidden = di.inject(shouldStartHiddenInjectable);
-        if (shouldShowLoadingWindow) {
+      const shouldShowLoadingWindow = !shouldStartHidden;
-          await splashWindow.start();
+      const splashWindow = di.inject(splashWindowInjectable);
-        }
+
-      },
+      if (shouldShowLoadingWindow) {
-    };
+        await splashWindow.start();
-  },
+      }
+    },
+  }),
   injectionToken: showLoadingRunnablePhaseInjectionToken,
 });
 

packages/core/src/main/start-main-application/runnables/stop-cluster-manager.injectable.ts

@@ -4,23 +4,20 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import clusterManagerInjectable from "../../cluster/manager.injectable";
-import { beforeQuitOfFrontEndInjectionToken } from "../runnable-tokens/before-quit-of-front-end-injection-token";
+import { beforeQuitOfFrontEndInjectionToken } from "../runnable-tokens/phases";
 
 const stopClusterManagerInjectable = getInjectable({
   id: "stop-cluster-manager",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const clusterManager = di.inject(clusterManagerInjectable);
+    run: () => {
+      const clusterManager = di.inject(clusterManagerInjectable);
 
-    return {
+      clusterManager.stop();
-      id: "stop-cluster-manager",
-      run: () => {
-        clusterManager.stop();
 
-        return undefined;
+      return undefined;
-      },
+    },
-    };
+  }),
-  },
 
   injectionToken: beforeQuitOfFrontEndInjectionToken,
 });

packages/core/src/main/start-main-application/start-main-application.injectable.ts

@@ -6,12 +6,8 @@ import { getInjectable } from "@ogre-tools/injectable";
 
 import { runManyFor } from "../../common/runnable/run-many-for";
 import { runManySyncFor } from "../../common/runnable/run-many-sync-for";
-import { beforeElectronIsReadyInjectionToken } from "./runnable-tokens/before-electron-is-ready-injection-token";
+import * as phases from "./runnable-tokens/phases";
-import { beforeApplicationIsLoadingInjectionToken } from "./runnable-tokens/before-application-is-loading-injection-token";
-import { onLoadOfApplicationInjectionToken } from "./runnable-tokens/on-load-of-application-injection-token";
-import { afterApplicationIsLoadedInjectionToken } from "./runnable-tokens/after-application-is-loaded-injection-token";
 import waitForElectronToBeReadyInjectable from "../electron-app/features/wait-for-electron-to-be-ready.injectable";
-import { appPathsRunnablePhaseInjectionToken, showInitialWindowRunnablePhaseInjectionToken, showLoadingRunnablePhaseInjectionToken } from "./runnable-tokens/phases";
 
 const startMainApplicationInjectable = getInjectable({
   id: "start-main-application",
@@ -21,13 +17,13 @@ const startMainApplicationInjectable = getInjectable({
     const runManySync = runManySyncFor(di);
     const waitForElectronToBeReady = di.inject(waitForElectronToBeReadyInjectable);
 
-    const appPathsRunnablePhase = runManySync(appPathsRunnablePhaseInjectionToken);
+    const appPathsRunnablePhase = runManySync(phases.appPathsRunnablePhaseInjectionToken);
-    const beforeElectronIsReady = runManySync(beforeElectronIsReadyInjectionToken);
+    const beforeElectronIsReady = runManySync(phases.beforeElectronIsReadyInjectionToken);
-    const beforeApplicationIsLoading = runMany(beforeApplicationIsLoadingInjectionToken);
+    const beforeApplicationIsLoading = runMany(phases.beforeApplicationIsLoadingInjectionToken);
-    const showLoadingRunnablePhase = runMany(showLoadingRunnablePhaseInjectionToken);
+    const showLoadingRunnablePhase = runMany(phases.showLoadingRunnablePhaseInjectionToken);
-    const onLoadOfApplication = runMany(onLoadOfApplicationInjectionToken);
+    const onLoadOfApplication = runMany(phases.onLoadOfApplicationInjectionToken);
-    const showInitialWindowRunnablePhase = runMany(showInitialWindowRunnablePhaseInjectionToken);
+    const showInitialWindowRunnablePhase = runMany(phases.showInitialWindowRunnablePhaseInjectionToken);
-    const afterApplicationIsLoaded = runMany(afterApplicationIsLoadedInjectionToken);
+    const afterApplicationIsLoaded = runMany(phases.afterApplicationIsLoadedInjectionToken);
 
     return () => {
       // Stuff happening before application is ready needs to be synchronous because of

packages/core/src/main/stores/init-user-store.injectable.ts

@@ -5,24 +5,21 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import userStoreFileNameMigrationInjectable from "../../common/user-store/file-name-migration.injectable";
 import userStoreInjectable from "../../common/user-store/user-store.injectable";
-import { beforeApplicationIsLoadingInjectionToken } from "../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../start-main-application/runnable-tokens/phases";
 import initDefaultUpdateChannelInjectable from "../vars/default-update-channel/init.injectable";
 
 const initUserStoreInjectable = getInjectable({
   id: "init-user-store",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const userStore = di.inject(userStoreInjectable);
+    run: async () => {
-    const userStoreFileNameMigration = di.inject(userStoreFileNameMigrationInjectable);
+      const userStore = di.inject(userStoreInjectable);
+      const userStoreFileNameMigration = di.inject(userStoreFileNameMigrationInjectable);
 
-    return {
+      await userStoreFileNameMigration();
-      id: "init-user-store",
+      userStore.load();
-      run: async () => {
+    },
-        await userStoreFileNameMigration();
+    runAfter: initDefaultUpdateChannelInjectable,
-        userStore.load();
+  }),
-      },
-      runAfter: di.inject(initDefaultUpdateChannelInjectable),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

packages/core/src/main/theme/sync-theme-from-os/start-syncing-theme-from-operating-system.injectable.ts

@@ -4,21 +4,18 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import syncThemeFromOperatingSystemInjectable from "../../electron-app/features/sync-theme-from-operating-system.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 
 const startSyncingThemeFromOperatingSystemInjectable = getInjectable({
   id: "start-syncing-theme-from-operating-system",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const syncTheme = di.inject(syncThemeFromOperatingSystemInjectable);
+    run: () => {
+      const syncTheme = di.inject(syncThemeFromOperatingSystemInjectable);
 
-    return {
+      syncTheme.start();
-      id: "start-syncing-theme-from-operating-system",
+    },
-      run: () => {
+  }),
-        syncTheme.start();
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/theme/sync-theme-from-os/stop-syncing-theme-from-operating-system.injectable.ts

@@ -4,19 +4,20 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import syncThemeFromOperatingSystemInjectable from "../../electron-app/features/sync-theme-from-operating-system.injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 
 const stopSyncingThemeFromOperatingSystemInjectable = getInjectable({
   id: "stop-syncing-theme-from-operating-system",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const syncTheme = di.inject(syncThemeFromOperatingSystemInjectable);
+    run: () => {
+      const syncTheme = di.inject(syncThemeFromOperatingSystemInjectable);
 
-    return {
+      syncTheme.stop();
-      id: "stop-syncing-theme-from-operating-system",
+
-      run: () => void syncTheme.stop(),
+      return undefined;
-    };
+    },
-  },
+  }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/main/tray/electron-tray/start-tray.injectable.ts

@@ -3,22 +3,19 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import electronTrayInjectable from "./electron-tray.injectable";
 
 const startTrayInjectable = getInjectable({
   id: "start-tray",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const electronTray = di.inject(electronTrayInjectable);
+    run: () => {
+      const electronTray = di.inject(electronTrayInjectable);
 
-    return {
+      electronTray.start();
-      id: "start-tray",
+    },
-      run: () => {
+  }),
-        electronTray.start();
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/tray/electron-tray/stop-tray.injectable.ts

@@ -4,21 +4,22 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import electronTrayInjectable from "./electron-tray.injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import stopReactiveTrayMenuItemsInjectable from "../reactive-tray-menu-items/stop-reactive-tray-menu-items.injectable";
 
 const stopTrayInjectable = getInjectable({
   id: "stop-tray",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const electronTray = di.inject(electronTrayInjectable);
+    run: () => {
+      const electronTray = di.inject(electronTrayInjectable);
 
-    return {
+      electronTray.stop();
-      id: "stop-tray",
+
-      run: () => void electronTray.stop(),
+      return undefined;
-      runAfter: di.inject(stopReactiveTrayMenuItemsInjectable),
+    },
-    };
+    runAfter: stopReactiveTrayMenuItemsInjectable,
-  },
+  }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/main/tray/menu-icon/start-reactivity.injectable.ts

@@ -3,25 +3,22 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import startTrayInjectable from "../electron-tray/start-tray.injectable";
 import reactiveTrayMenuIconInjectable from "./reactive.injectable";
 
 const startReactiveTrayMenuIconInjectable = getInjectable({
   id: "start-reactive-tray-menu-icon",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const reactiveTrayMenuIcon = di.inject(reactiveTrayMenuIconInjectable);
+    run: () => {
+      const reactiveTrayMenuIcon = di.inject(reactiveTrayMenuIconInjectable);
 
-    return {
+      reactiveTrayMenuIcon.start();
-      id: "start-reactive-tray-menu-icon",
+    },
-      run: () => {
-        reactiveTrayMenuIcon.start();
-      },
 
-      runAfter: di.inject(startTrayInjectable),
+    runAfter: startTrayInjectable,
-    };
+  }),
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/tray/menu-icon/stop-reactivity.injectable.ts

@@ -3,20 +3,21 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import reactiveTrayMenuIconInjectable from "./reactive.injectable";
 
 const stopReactiveTrayMenuIconInjectable = getInjectable({
   id: "stop-reactive-tray-menu-icon",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const reactiveTrayMenuIcon = di.inject(reactiveTrayMenuIconInjectable);
+    run: () => {
+      const reactiveTrayMenuIcon = di.inject(reactiveTrayMenuIconInjectable);
 
-    return {
+      reactiveTrayMenuIcon.stop();
-      id: "stop-reactive-tray-menu-icon",
+
-      run: () => void reactiveTrayMenuIcon.stop(),
+      return undefined;
-    };
+    },
-  },
+  }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/main/tray/reactive-tray-menu-items/start-reactive-tray-menu-items.injectable.ts

@@ -4,24 +4,20 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import reactiveTrayMenuItemsInjectable from "./reactive-tray-menu-items.injectable";
-import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import startTrayInjectable from "../electron-tray/start-tray.injectable";
 
 const startReactiveTrayMenuItemsInjectable = getInjectable({
   id: "start-reactive-tray-menu-items",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const reactiveTrayMenuItems = di.inject(reactiveTrayMenuItemsInjectable);
+    run: () => {
+      const reactiveTrayMenuItems = di.inject(reactiveTrayMenuItemsInjectable);
 
-    return {
+      reactiveTrayMenuItems.start();
-      id: "start-reactive-tray-menu-items",
+    },
-      run: () => {
+    runAfter: startTrayInjectable,
-        reactiveTrayMenuItems.start();
+  }),
-      },
-
-      runAfter: di.inject(startTrayInjectable),
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/tray/reactive-tray-menu-items/stop-reactive-tray-menu-items.injectable.ts

@@ -4,19 +4,20 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import reactiveTrayMenuItemsInjectable from "./reactive-tray-menu-items.injectable";
-import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+import { beforeQuitOfBackEndInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 
 const stopReactiveTrayMenuItemsInjectable = getInjectable({
   id: "stop-reactive-tray-menu-items",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const reactiveTrayMenuItems = di.inject(reactiveTrayMenuItemsInjectable);
+    run: () => {
+      const reactiveTrayMenuItems = di.inject(reactiveTrayMenuItemsInjectable);
 
-    return {
+      reactiveTrayMenuItems.stop();
-      id: "stop-reactive-tray-menu-items",
+
-      run: () => void reactiveTrayMenuItems.stop(),
+      return undefined;
-    };
+    },
-  },
+  }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,
 });

packages/core/src/main/user-store/sync-open-at-login-with-os.injectable.ts

@@ -6,29 +6,26 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { reaction } from "mobx";
 import userStoreInjectable from "../../common/user-store/user-store.injectable";
 import setLoginItemSettingsInjectable from "../electron-app/features/set-login-item-settings.injectable";
-import { onLoadOfApplicationInjectionToken } from "../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../start-main-application/runnable-tokens/phases";
 
 const setupSyncOpenAtLoginWithOsInjectable = getInjectable({
   id: "setup-sync-open-at-login-with-os",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const setLoginItemSettings = di.inject(setLoginItemSettingsInjectable);
+    run: () => {
-    const userStore = di.inject(userStoreInjectable);
+      const setLoginItemSettings = di.inject(setLoginItemSettingsInjectable);
+      const userStore = di.inject(userStoreInjectable);
 
-    return {
+      reaction(() => userStore.openAtLogin, openAtLogin => {
-      id: "setup-sync-open-at-login-with-os",
+        setLoginItemSettings({
-      run: () => {
+          openAtLogin,
-        reaction(() => userStore.openAtLogin, openAtLogin => {
+          openAsHidden: true,
-          setLoginItemSettings({
+          args: ["--hidden"],
-            openAtLogin,
-            openAsHidden: true,
-            args: ["--hidden"],
-          });
-        }, {
-          fireImmediately: true,
         });
-      },
+      }, {
-    };
+        fireImmediately: true,
-  },
+      });
+    },
+  }),
   injectionToken: onLoadOfApplicationInjectionToken,
 });
 

packages/core/src/main/utils/channel/channel-listeners/start-listening-on-channels.injectable.ts

@@ -3,25 +3,22 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { onLoadOfApplicationInjectionToken } from "../../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import { onLoadOfApplicationInjectionToken } from "../../../start-main-application/runnable-tokens/phases";
 import listeningOnMessageChannelsInjectable from "../../../../common/utils/channel/listening-on-message-channels.injectable";
 import listeningOnRequestChannelsInjectable from "./listening-on-request-channels.injectable";
 
 const startListeningOnChannelsInjectable = getInjectable({
   id: "start-listening-on-channels-main",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const listeningOnMessageChannels = di.inject(listeningOnMessageChannelsInjectable);
+    run: () => {
-    const listeningOnRequestChannels = di.inject(listeningOnRequestChannelsInjectable);
+      const listeningOnMessageChannels = di.inject(listeningOnMessageChannelsInjectable);
+      const listeningOnRequestChannels = di.inject(listeningOnRequestChannelsInjectable);
 
-    return {
+      listeningOnMessageChannels.start();
-      id: "start-listening-on-channels-main",
+      listeningOnRequestChannels.start();
-      run: () => {
+    },
-        listeningOnMessageChannels.start();
+  }),
-        listeningOnRequestChannels.start();
-      },
-    };
-  },
 
   injectionToken: onLoadOfApplicationInjectionToken,
 });

packages/core/src/main/vars/build-version/init.injectable.ts

@@ -3,19 +3,18 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import buildVersionInjectable from "./build-version.injectable";
 
 const initializeBuildVersionInjectable = getInjectable({
   id: "initialize-build-version",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const buildVersion = di.inject(buildVersionInjectable);
+    run: async () => {
+      const buildVersion = di.inject(buildVersionInjectable);
 
-    return {
+      await buildVersion.init();
-      id: "initialize-build-version",
+    },
-      run: () => buildVersion.init(),
+  }),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

packages/core/src/main/vars/default-update-channel/init.injectable.ts

@@ -3,21 +3,20 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import initReleaseChannelInjectable from "../release-channel/init.injectable";
 import defaultUpdateChannelInjectable from "../../../features/application-update/common/selected-update-channel/default-update-channel.injectable";
 
 const initDefaultUpdateChannelInjectable = getInjectable({
   id: "init-default-update-channel",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
+    run: async () => {
+      const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
 
-    return {
+      await defaultUpdateChannel.init();
-      id: "init-default-update-channel",
+    },
-      run: () => defaultUpdateChannel.init(),
+    runAfter: initReleaseChannelInjectable,
-      runAfter: di.inject(initReleaseChannelInjectable),
+  }),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

packages/core/src/main/vars/release-channel/init.injectable.ts

@@ -4,20 +4,19 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import releaseChannelInjectable from "../../../common/vars/release-channel.injectable";
-import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import initSemanticBuildVersionInjectable from "../semantic-build-version/init.injectable";
 
 const initReleaseChannelInjectable = getInjectable({
   id: "init-release-channel",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const releaseChannel = di.inject(releaseChannelInjectable);
+    run: async () => {
+      const releaseChannel = di.inject(releaseChannelInjectable);
 
-    return {
+      await releaseChannel.init();
-      id: "init-release-channel",
+    },
-      run: () => releaseChannel.init(),
+    runAfter: initSemanticBuildVersionInjectable,
-      runAfter: di.inject(initSemanticBuildVersionInjectable),
+  }),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

packages/core/src/main/vars/semantic-build-version/init.injectable.ts

@@ -4,18 +4,19 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import buildSemanticVersionInjectable from "../../../common/vars/build-semantic-version.injectable";
-import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/phases";
 import initializeBuildVersionInjectable from "../build-version/init.injectable";
 
 const initSemanticBuildVersionInjectable = getInjectable({
   id: "init-semantic-build-version",
   instantiate: (di) => {
-    const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
-
     return {
-      id: "init-semantic-build-version",
+      run: async () => {
-      run: () => buildSemanticVersion.init(),
+        const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
-      runAfter: di.inject(initializeBuildVersionInjectable),
+
+        await buildSemanticVersion.init();
+      },
+      runAfter: initializeBuildVersionInjectable,
     };
   },
   injectionToken: beforeApplicationIsLoadingInjectionToken,

packages/core/src/renderer/app-paths/setup-app-paths.injectable.ts

@@ -12,7 +12,6 @@ const setupAppPathsInjectable = getInjectable({
   id: "setup-app-paths",
 
   instantiate: (di) => ({
-    id: "setup-app-paths",
     run: async () => {
       const requestFromChannel = di.inject(requestFromChannelInjectionToken);
       const appPathsState = di.inject(appPathsStateInjectable);

packages/core/src/renderer/before-frame-starts/runnables/configure-immer.injectable.ts

@@ -9,7 +9,6 @@ import { beforeFrameStartsFirstInjectionToken } from "../tokens";
 const configureImmerInjectable = getInjectable({
   id: "configure-immer",
   instantiate: () => ({
-    id: "configure-immer",
     run: () => {
       // Docs: https://immerjs.github.io/immer/
       // Required in `utils/storage-helper.ts`

packages/core/src/renderer/before-frame-starts/runnables/configure-mobx.injectable.ts

@@ -9,7 +9,6 @@ import { beforeFrameStartsFirstInjectionToken } from "../tokens";
 const configureMobxInjectable = getInjectable({
   id: "configure-mobx",
   instantiate: () => ({
-    id: "configure-mobx",
     run: () => {
       // Docs: https://mobx.js.org/configuration.html
       configure({

packages/core/src/renderer/before-frame-starts/runnables/load-monaco-themes.injectable.ts

@@ -10,7 +10,6 @@ import { beforeFrameStartsSecondInjectionToken } from "../tokens";
 const loadMonacoThemesInjectable = getInjectable({
   id: "load-monaco-themes",
   instantiate: (di) => ({
-    id: "load-monaco-themes",
     run: () => {
       const customThemes = di.injectMany(customMonacoThemeInjectionToken);
       const addNewMonacoTheme = di.inject(addNewMonacoThemeInjectable);

packages/core/src/renderer/before-frame-starts/runnables/setup-auto-registration.injectable.ts

@@ -19,7 +19,6 @@ import maybeKubeApiInjectable from "../../../common/k8s-api/maybe-kube-api.injec
 const setupAutoRegistrationInjectable = getInjectable({
   id: "setup-auto-registration",
   instantiate: (di) => ({
-    id: "setup-auto-registration",
     run: () => {
       const autoRegistrationEmitter = di.inject(autoRegistrationEmitterInjectable);
       const beforeApiManagerInitializationCrds: CustomResourceDefinition[] = [];

packages/core/src/renderer/before-frame-starts/runnables/setup-current-cluster-broadcast.injectable.ts

@@ -12,7 +12,6 @@ import { beforeMainFrameStartsFirstInjectionToken } from "../tokens";
 const setupCurrentClusterBroadcastInjectable = getInjectable({
   id: "setup-current-cluster-broadcast",
   instantiate: (di) => ({
-    id: "setup-current-cluster-broadcast",
     run: () => {
       const matchedClusterId = di.inject(matchedClusterIdInjectable);
       const sendMessageToChannel = di.inject(sendMessageToChannelInjectionToken);

packages/core/src/renderer/before-frame-starts/runnables/setup-kubernetes-cluster-catalog-add-menu.injectable.ts

@@ -14,7 +14,6 @@ import { beforeFrameStartsSecondInjectionToken } from "../tokens";
 const setupKubernetesClusterCatalogAddMenuListenerInjectable = getInjectable({
   id: "setup-kubernetes-cluster-catalog-add-menu-listener",
   instantiate: (di) => ({
-    id: "setup-kubernetes-cluster-catalog-add-menu-listener",
     run: () => {
       const navigateToAddCluster = di.inject(navigateToAddClusterInjectable);
       const addSyncEntries = di.inject(addSyncEntriesInjectable);

packages/core/src/renderer/before-frame-starts/runnables/setup-kubernetes-cluster-context-menu-open.injectable.ts

@@ -14,7 +14,6 @@ import { beforeFrameStartsSecondInjectionToken } from "../tokens";
 const setupKubernetesClusterContextMenuOpenInjectable = getInjectable({
   id: "setup-kubernetes-cluster-context-menu-open",
   instantiate: (di) => ({
-    id: "setup-kubernetes-cluster-context-menu-open",
     run: () => {
       const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
       const openDeleteClusterDialog = di.inject(openDeleteClusterDialogInjectable);

packages/core/src/renderer/before-frame-starts/runnables/setup-lens-proxy-certificate.injectable.ts

@@ -10,7 +10,6 @@ import requestLensProxyCertificateInjectable from "../../certificate/request-len
 const setupLensProxyCertificateInjectable = getInjectable({
   id: "setup-lens-proxy-certificate",
   instantiate: (di) => ({
-    id: "setup-lens-proxy-certificate",
     run: async () => {
       const requestLensProxyCertificate = di.inject(requestLensProxyCertificateInjectable);
       const lensProxyCertificate = di.inject(lensProxyCertificateInjectable);

packages/core/src/renderer/before-frame-starts/runnables/setup-root-mac-class.injectable.ts

@@ -9,7 +9,6 @@ import { beforeFrameStartsSecondInjectionToken } from "../tokens";
 const setupRootMacClassnameInjectable = getInjectable({
   id: "setup-root-mac-classname",
   instantiate: (di) => ({
-    id: "setup-root-mac-classname",
     run: () => {
       const isMac = di.inject(isMacInjectable);
       const rootElem = document.getElementById("app");

packages/core/src/renderer/before-frame-starts/runnables/setup-sentry.injectable.ts

@@ -10,7 +10,6 @@ import { init } from "@sentry/electron/renderer";
 const setupSentryInjectable = getInjectable({
   id: "setup-sentry",
   instantiate: (di) => ({
-    id: "setup-sentry",
     run: () => {
       const initializeSentryReportingWith = di.inject(initializeSentryReportingWithInjectable);
 

packages/core/src/renderer/before-frame-starts/runnables/setup-weblink-context-menu-open.injectable.tsx

@@ -9,10 +9,9 @@ import { WeblinkAddCommand } from "../../components/catalog-entities/weblink-add
 import commandOverlayInjectable from "../../components/command-palette/command-overlay.injectable";
 import { beforeFrameStartsSecondInjectionToken } from "../tokens";
 
-const setupWeblickContextMenuOpenInjectable = getInjectable({
+const setupWeblinkContextMenuOpenInjectable = getInjectable({
-  id: "setup-weblick-context-menu-open",
+  id: "setup-weblink-context-menu-open",
   instantiate: (di) => ({
-    id: "setup-weblick-context-menu-open",
     run: () => {
       const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
       const commandOverlay = di.inject(commandOverlayInjectable);
@@ -31,4 +30,4 @@ const setupWeblickContextMenuOpenInjectable = getInjectable({
   injectionToken: beforeFrameStartsSecondInjectionToken,
 });
 
-export default setupWeblickContextMenuOpenInjectable;
+export default setupWeblinkContextMenuOpenInjectable;

packages/core/src/renderer/before-frame-starts/tokens.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectionToken } from "@ogre-tools/injectable";
-import type { Runnable } from "../../common/runnable/run-many-for";
+import type { Runnable } from "../../common/runnable/types";
 
 // NOTE: these are run before any other token, mostly to set up things that all other runnables need
 export const beforeFrameStartsFirstInjectionToken = getInjectionToken<Runnable>({