diff --git a/src/features/cluster/state-sync/renderer/setup-sync.injectable.ts b/src/features/cluster/state-sync/renderer/setup-sync.injectable.ts
index c66d14cbc5..93005543db 100644
--- a/src/features/cluster/state-sync/renderer/setup-sync.injectable.ts
+++ b/src/features/cluster/state-sync/renderer/setup-sync.injectable.ts
@@ -10,22 +10,19 @@ import requestInitialClusterStatesInjectable from "./request-initial.injectable"
 
 const setupClusterStateSyncInjectable = getInjectable({
   id: "setup-cluster-state-sync",
-  instantiate: (di) => {
-    const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
-    const getClusterById = di.inject(getClusterByIdInjectable);
+  instantiate: (di) => ({
+    id: "setup-cluster-state-sync",
+    run: async () => {
+      const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
+      const getClusterById = di.inject(getClusterByIdInjectable);
+      const initalStates = await requestInitialClusterStates();
 
-    return {
-      id: "setup-cluster-state-sync",
-      run: async () => {
-        const initalStates = await requestInitialClusterStates();
-
-        for (const { clusterId, state } of initalStates) {
-          getClusterById(clusterId)?.setState(state);
-        }
-      },
-      runAfter: di.inject(initClusterStoreInjectable),
-    };
-  },
+      for (const { clusterId, state } of initalStates) {
+        getClusterById(clusterId)?.setState(state);
+      }
+    },
+    runAfter: di.inject(initClusterStoreInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/features/cluster/store/renderer/init.injectable.ts b/src/features/cluster/store/renderer/init.injectable.ts
index 1eab16903b..2c2795de5c 100644
--- a/src/features/cluster/store/renderer/init.injectable.ts
+++ b/src/features/cluster/store/renderer/init.injectable.ts
@@ -9,17 +9,15 @@ import initUserStoreInjectable from "../../../../renderer/stores/init-user-store
 
 const initClusterStoreInjectable = getInjectable({
   id: "init-cluster-store",
-  instantiate: (di) => {
-    const clusterStore = di.inject(clusterStoreInjectable);
+  instantiate: (di) => ({
+    id: "init-cluster-store",
+    run: () => {
+      const clusterStore = di.inject(clusterStoreInjectable);
 
-    return {
-      id: "init-cluster-store",
-      run: () => {
-        clusterStore.load();
-      },
-      runAfter: di.inject(initUserStoreInjectable),
-    };
-  },
+      clusterStore.load();
+    },
+    runAfter: di.inject(initUserStoreInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/features/hotbar/store/renderer/init.injectable.ts b/src/features/hotbar/store/renderer/init.injectable.ts
index 662c3f3311..6d341f1ee8 100644
--- a/src/features/hotbar/store/renderer/init.injectable.ts
+++ b/src/features/hotbar/store/renderer/init.injectable.ts
@@ -9,17 +9,15 @@ import initClusterStoreInjectable from "../../../cluster/store/renderer/init.inj
 
 const initHotbarStoreInjectable = getInjectable({
   id: "init-hotbar-store",
-  instantiate: (di) => {
-    const hotbarStore = di.inject(hotbarStoreInjectable);
+  instantiate: (di) => ({
+    id: "init-hotbar-store",
+    run: () => {
+      const hotbarStore = di.inject(hotbarStoreInjectable);
 
-    return {
-      id: "init-hotbar-store",
-      run: () => {
-        hotbarStore.load();
-      },
-      runAfter: di.inject(initClusterStoreInjectable),
-    };
-  },
+      hotbarStore.load();
+    },
+    runAfter: di.inject(initClusterStoreInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/features/theme/system-type/renderer/initialize.injectable.ts b/src/features/theme/system-type/renderer/initialize.injectable.ts
index a80563b7b1..e6ed81f4f1 100644
--- a/src/features/theme/system-type/renderer/initialize.injectable.ts
+++ b/src/features/theme/system-type/renderer/initialize.injectable.ts
@@ -10,18 +10,16 @@ import requestInitialSystemThemeTypeInjectable from "./request-initial.injectabl
 
 const initializeSystemThemeTypeInjectable = getInjectable({
   id: "initialize-system-theme-type",
-  instantiate: (di) => {
-    const systemThemeConfiguration = di.inject(systemThemeConfigurationInjectable);
-    const requestInitialSystemThemeType = di.inject(requestInitialSystemThemeTypeInjectable);
+  instantiate: (di) => ({
+    id: "initialize-system-theme-type",
+    run: async () => {
+      const systemThemeConfiguration = di.inject(systemThemeConfigurationInjectable);
+      const requestInitialSystemThemeType = di.inject(requestInitialSystemThemeTypeInjectable);
 
-    return {
-      id: "initialize-system-theme-type",
-      run: async () => {
-        systemThemeConfiguration.set(await requestInitialSystemThemeType());
-      },
-      runAfter: di.inject(initUserStoreInjectable),
-    };
-  },
+      systemThemeConfiguration.set(await requestInitialSystemThemeType());
+    },
+    runAfter: di.inject(initUserStoreInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/renderer/app-paths/setup-app-paths.injectable.ts b/src/renderer/app-paths/setup-app-paths.injectable.ts
index 70194e4ce6..e9030edb43 100644
--- a/src/renderer/app-paths/setup-app-paths.injectable.ts
+++ b/src/renderer/app-paths/setup-app-paths.injectable.ts
@@ -11,19 +11,16 @@ import { requestFromChannelInjectionToken } from "../../common/utils/channel/req
 const setupAppPathsInjectable = getInjectable({
   id: "setup-app-paths",
 
-  instantiate: (di) => {
-    const requestFromChannel = di.inject(requestFromChannelInjectionToken);
-    const appPathsState = di.inject(appPathsStateInjectable);
+  instantiate: (di) => ({
+    id: "setup-app-paths",
+    run: async () => {
+      const requestFromChannel = di.inject(requestFromChannelInjectionToken);
+      const appPathsState = di.inject(appPathsStateInjectable);
+      const appPaths = await requestFromChannel(appPathsChannel);
 
-    return {
-      id: "setup-app-paths",
-      run: async () => {
-        const appPaths = await requestFromChannel(appPathsChannel);
-
-        appPathsState.set(appPaths);
-      },
-    };
-  },
+      appPathsState.set(appPaths);
+    },
+  }),
 
   injectionToken: beforeFrameStartsInjectionToken,
 });
diff --git a/src/renderer/before-frame-starts/runnables/load-monaco-themes.injectable.ts b/src/renderer/before-frame-starts/runnables/load-monaco-themes.injectable.ts
index 09f4813477..e425b7192f 100644
--- a/src/renderer/before-frame-starts/runnables/load-monaco-themes.injectable.ts
+++ b/src/renderer/before-frame-starts/runnables/load-monaco-themes.injectable.ts
@@ -9,17 +9,15 @@ import { evenBeforeFrameStartsInjectionToken } from "../tokens";
 
 const loadMonacoThemesInjectable = getInjectable({
   id: "load-monaco-themes",
-  instantiate: (di) => {
-    const customThemes = di.injectMany(customMonacoThemeInjectionToken);
-    const addNewMonacoTheme = di.inject(addNewMonacoThemeInjectable);
+  instantiate: (di) => ({
+    id: "load-monaco-themes",
+    run: () => {
+      const customThemes = di.injectMany(customMonacoThemeInjectionToken);
+      const addNewMonacoTheme = di.inject(addNewMonacoThemeInjectable);
 
-    return {
-      id: "load-monaco-themes",
-      run: () => {
-        customThemes.forEach(addNewMonacoTheme);
-      },
-    };
-  },
+      customThemes.forEach(addNewMonacoTheme);
+    },
+  }),
   injectionToken: evenBeforeFrameStartsInjectionToken,
 });
 
diff --git a/src/renderer/before-frame-starts/runnables/setup-current-cluster-broadcast.injectable.ts b/src/renderer/before-frame-starts/runnables/setup-current-cluster-broadcast.injectable.ts
index 4fe8a7d266..ab9e8ba81c 100644
--- a/src/renderer/before-frame-starts/runnables/setup-current-cluster-broadcast.injectable.ts
+++ b/src/renderer/before-frame-starts/runnables/setup-current-cluster-broadcast.injectable.ts
@@ -11,23 +11,21 @@ import { evenBeforeMainFrameStartsInjectionToken } from "../tokens";
 
 const setupCurrentClusterBroadcastInjectable = getInjectable({
   id: "setup-current-cluster-broadcast",
-  instantiate: (di) => {
-    const matchedClusterId = di.inject(matchedClusterIdInjectable);
-    const sendMessageToChannel = di.inject(sendMessageToChannelInjectionToken);
+  instantiate: (di) => ({
+    id: "setup-current-cluster-broadcast",
+    run: () => {
+      const matchedClusterId = di.inject(matchedClusterIdInjectable);
+      const sendMessageToChannel = di.inject(sendMessageToChannelInjectionToken);
 
-    return {
-      id: "setup-current-cluster-broadcast",
-      run: () => {
-        reaction(
-          () => matchedClusterId.get(),
-          clusterId => sendMessageToChannel(currentClusterMessageChannel, clusterId),
-          {
-            fireImmediately: true,
-          },
-        );
-      },
-    };
-  },
+      reaction(
+        () => matchedClusterId.get(),
+        clusterId => sendMessageToChannel(currentClusterMessageChannel, clusterId),
+        {
+          fireImmediately: true,
+        },
+      );
+    },
+  }),
   injectionToken: evenBeforeMainFrameStartsInjectionToken,
 });
 
diff --git a/src/renderer/before-frame-starts/runnables/setup-root-mac-class.injectable.ts b/src/renderer/before-frame-starts/runnables/setup-root-mac-class.injectable.ts
index fa2d00ab27..59a684ccc9 100644
--- a/src/renderer/before-frame-starts/runnables/setup-root-mac-class.injectable.ts
+++ b/src/renderer/before-frame-starts/runnables/setup-root-mac-class.injectable.ts
@@ -8,18 +8,15 @@ import { beforeFrameStartsInjectionToken } from "../tokens";
 
 const setupRootMacClassnameInjectable = getInjectable({
   id: "setup-root-mac-classname",
-  instantiate: (di) => {
-    const isMac = di.inject(isMacInjectable);
+  instantiate: (di) => ({
+    id: "setup-root-mac-classname",
+    run: () => {
+      const isMac = di.inject(isMacInjectable);
+      const rootElem = document.getElementById("app");
 
-    return {
-      id: "setup-root-mac-classname",
-      run: () => {
-        const rootElem = document.getElementById("app");
-
-        rootElem?.classList.toggle("is-mac", isMac);
-      },
-    };
-  },
+      rootElem?.classList.toggle("is-mac", isMac);
+    },
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/renderer/before-frame-starts/runnables/setup-weblink-context-menu-open.injectable.tsx b/src/renderer/before-frame-starts/runnables/setup-weblink-context-menu-open.injectable.tsx
index 5d7e0f5f12..4c027d6047 100644
--- a/src/renderer/before-frame-starts/runnables/setup-weblink-context-menu-open.injectable.tsx
+++ b/src/renderer/before-frame-starts/runnables/setup-weblink-context-menu-open.injectable.tsx
@@ -11,25 +11,23 @@ import { beforeFrameStartsInjectionToken } from "../tokens";
 
 const setupWeblickContextMenuOpenInjectable = getInjectable({
   id: "setup-weblick-context-menu-open",
-  instantiate: (di) => {
-    const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
-    const commandOverlay = di.inject(commandOverlayInjectable);
+  instantiate: (di) => ({
+    id: "setup-weblick-context-menu-open",
+    run: () => {
+      const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
+      const commandOverlay = di.inject(commandOverlayInjectable);
 
-    return {
-      id: "setup-weblick-context-menu-open",
-      run: () => {
-        catalogCategoryRegistry
-          .getForGroupKind("entity.k8slens.dev", "WebLink")
-          ?.on("catalogAddMenu", ctx => {
-            ctx.menuItems.push({
-              title: "Add web link",
-              icon: "public",
-              onClick: () => commandOverlay.open(<WeblinkAddCommand />),
-            });
+      catalogCategoryRegistry
+        .getForGroupKind("entity.k8slens.dev", "WebLink")
+        ?.on("catalogAddMenu", ctx => {
+          ctx.menuItems.push({
+            title: "Add web link",
+            icon: "public",
+            onClick: () => commandOverlay.open(<WeblinkAddCommand />),
           });
-      },
-    };
-  },
+        });
+    },
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/renderer/components/layout/top-bar/start-state-sync.injectable.ts b/src/renderer/components/layout/top-bar/start-state-sync.injectable.ts
index 956d3cb851..666966ddad 100644
--- a/src/renderer/components/layout/top-bar/start-state-sync.injectable.ts
+++ b/src/renderer/components/layout/top-bar/start-state-sync.injectable.ts
@@ -11,23 +11,21 @@ import topBarStateInjectable from "./state.injectable";
 // TODO: replace with a SyncBox
 const startTopbarStateSyncInjectable = getInjectable({
   id: "start-topbar-state-sync",
-  instantiate: (di) => {
-    const state = di.inject(topBarStateInjectable);
-    const ipcRenderer = di.inject(ipcRendererInjectable);
+  instantiate: (di) => ({
+    id: "start-topbar-state-sync",
+    run: () => {
+      const state = di.inject(topBarStateInjectable);
+      const ipcRenderer = di.inject(ipcRendererInjectable);
 
-    return {
-      id: "start-topbar-state-sync",
-      run: () => {
-        ipcRenderer.on("history:can-go-back", action((event, canGoBack: boolean) => {
-          state.prevEnabled = canGoBack;
-        }));
+      ipcRenderer.on("history:can-go-back", action((event, canGoBack: boolean) => {
+        state.prevEnabled = canGoBack;
+      }));
 
-        ipcRenderer.on("history:can-go-forward", action((event, canGoForward: boolean) => {
-          state.nextEnabled = canGoForward;
-        }));
-      },
-    };
-  },
+      ipcRenderer.on("history:can-go-forward", action((event, canGoForward: boolean) => {
+        state.nextEnabled = canGoForward;
+      }));
+    },
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
   causesSideEffects: true,
 });
diff --git a/src/renderer/utils/channel/channel-listeners/start-listening-of-channels.injectable.ts b/src/renderer/utils/channel/channel-listeners/start-listening-of-channels.injectable.ts
index 6403b9854a..ab9224c71b 100644
--- a/src/renderer/utils/channel/channel-listeners/start-listening-of-channels.injectable.ts
+++ b/src/renderer/utils/channel/channel-listeners/start-listening-of-channels.injectable.ts
@@ -5,20 +5,20 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { beforeFrameStartsInjectionToken } from "../../../before-frame-starts/tokens";
 import listeningOnMessageChannelsInjectable from "../../../../common/utils/channel/listening-on-message-channels.injectable";
+import setupAppPathsInjectable from "../../../app-paths/setup-app-paths.injectable";
 
 const startListeningOfChannelsInjectable = getInjectable({
   id: "start-listening-of-channels-renderer",
 
-  instantiate: (di) => {
-    const listeningOfChannels = di.inject(listeningOnMessageChannelsInjectable);
+  instantiate: (di) => ({
+    id: "start-listening-of-channels-renderer",
+    run: () => {
+      const listeningOfChannels = di.inject(listeningOnMessageChannelsInjectable);
 
-    return {
-      id: "start-listening-of-channels-renderer",
-      run: () => {
-        listeningOfChannels.start();
-      },
-    };
-  },
+      listeningOfChannels.start();
+    },
+    runAfter: di.inject(setupAppPathsInjectable),
+  }),
 
   injectionToken: beforeFrameStartsInjectionToken,
 });
diff --git a/src/renderer/utils/sync-box/provide-initial-values-for-sync-boxes.injectable.ts b/src/renderer/utils/sync-box/provide-initial-values-for-sync-boxes.injectable.ts
index 056bde67f2..f813445855 100644
--- a/src/renderer/utils/sync-box/provide-initial-values-for-sync-boxes.injectable.ts
+++ b/src/renderer/utils/sync-box/provide-initial-values-for-sync-boxes.injectable.ts
@@ -8,38 +8,29 @@ import { syncBoxInitialValueChannel } from "../../../common/utils/sync-box/chann
 import createSyncBoxStateInjectable from "../../../common/utils/sync-box/sync-box-state.injectable";
 import { requestFromChannelInjectionToken } from "../../../common/utils/channel/request-from-channel-injection-token";
 import { runInAction } from "mobx";
-import type { SyncBox } from "../../../common/utils/sync-box/sync-box-injection-token";
 import { syncBoxInjectionToken } from "../../../common/utils/sync-box/sync-box-injection-token";
 import assert from "assert";
 
 const provideInitialValuesForSyncBoxesInjectable = getInjectable({
   id: "provide-initial-values-for-sync-boxes",
 
-  instantiate: (di) => {
-    const requestFromChannel = di.inject(requestFromChannelInjectionToken);
+  instantiate: (di) => ({
+    id: "provide-initial-values-for-sync-boxes",
+    run: async () => {
+      const requestFromChannel = di.inject(requestFromChannelInjectionToken);
+      const syncBoxes = di.injectMany(syncBoxInjectionToken);
+      const initialValues = await requestFromChannel(syncBoxInitialValueChannel);
 
-    const syncBoxes = di.injectMany(syncBoxInjectionToken);
+      runInAction(() => {
+        for (const { id, value } of initialValues) {
+          const syncBox = syncBoxes.find((box) => box.id === id);
 
-    const setSyncBoxState = (syncBox: SyncBox<any>, state: any) =>
-      di.inject(createSyncBoxStateInjectable, syncBox.id).set(state);
-
-    return {
-      id: "provide-initial-values-for-sync-boxes",
-      run: async () => {
-        const initialValues = await requestFromChannel(syncBoxInitialValueChannel);
-
-        runInAction(() => {
-          initialValues.forEach(({ id, value }) => {
-            const syncBox = syncBoxes.find((box) => box.id === id);
-
-            assert(syncBox);
-
-            setSyncBoxState(syncBox, value);
-          });
-        });
-      },
-    };
-  },
+          assert(syncBox);
+          di.inject(createSyncBoxStateInjectable, syncBox.id).set(value);
+        }
+      });
+    },
+  }),
 
   injectionToken: beforeFrameStartsInjectionToken,
 });
diff --git a/src/renderer/vars/build-version/init.injectable.ts b/src/renderer/vars/build-version/init.injectable.ts
index e0bd7d8423..7e7b7e9876 100644
--- a/src/renderer/vars/build-version/init.injectable.ts
+++ b/src/renderer/vars/build-version/init.injectable.ts
@@ -8,14 +8,14 @@ import buildVersionInjectable from "./build-version.injectable";
 
 const initializeBuildVersionInjectable = getInjectable({
   id: "initialize-build-version",
-  instantiate: (di) => {
-    const buildVersion = di.inject(buildVersionInjectable);
+  instantiate: (di) => ({
+    id: "initialize-build-version",
+    run: async () => {
+      const buildVersion = di.inject(buildVersionInjectable);
 
-    return {
-      id: "initialize-build-version",
-      run: () => buildVersion.init(),
-    };
-  },
+      await buildVersion.init();
+    },
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/renderer/vars/default-update-channel/init.injectable.ts b/src/renderer/vars/default-update-channel/init.injectable.ts
index 1489f7c42d..c7435230c8 100644
--- a/src/renderer/vars/default-update-channel/init.injectable.ts
+++ b/src/renderer/vars/default-update-channel/init.injectable.ts
@@ -9,15 +9,15 @@ import defaultUpdateChannelInjectable from "../../../features/application-update
 
 const initDefaultUpdateChannelInjectable = getInjectable({
   id: "init-default-update-channel",
-  instantiate: (di) => {
-    const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
+  instantiate: (di) => ({
+    id: "init-default-update-channel",
+    run: async () => {
+      const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
 
-    return {
-      id: "init-default-update-channel",
-      run: () => defaultUpdateChannel.init(),
-      runAfter: di.inject(initReleaseChannelInjectable),
-    };
-  },
+      await defaultUpdateChannel.init();
+    },
+    runAfter: di.inject(initReleaseChannelInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/renderer/vars/release-channel/init.injectable.ts b/src/renderer/vars/release-channel/init.injectable.ts
index 47a35e2d8d..016ec0826d 100644
--- a/src/renderer/vars/release-channel/init.injectable.ts
+++ b/src/renderer/vars/release-channel/init.injectable.ts
@@ -9,15 +9,15 @@ import initSemanticBuildVersionInjectable from "../semantic-build-version/init.i
 
 const initReleaseChannelInjectable = getInjectable({
   id: "init-release-channel",
-  instantiate: (di) => {
-    const releaseChannel = di.inject(releaseChannelInjectable);
+  instantiate: (di) => ({
+    id: "init-release-channel",
+    run: async () => {
+      const releaseChannel = di.inject(releaseChannelInjectable);
 
-    return {
-      id: "init-release-channel",
-      run: () => releaseChannel.init(),
-      runAfter: di.inject(initSemanticBuildVersionInjectable),
-    };
-  },
+      await releaseChannel.init();
+    },
+    runAfter: di.inject(initSemanticBuildVersionInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
diff --git a/src/renderer/vars/semantic-build-version/init.injectable.ts b/src/renderer/vars/semantic-build-version/init.injectable.ts
index 3ac41a50e1..bf9d3e02d4 100644
--- a/src/renderer/vars/semantic-build-version/init.injectable.ts
+++ b/src/renderer/vars/semantic-build-version/init.injectable.ts
@@ -9,15 +9,15 @@ import initializeBuildVersionInjectable from "../build-version/init.injectable";
 
 const initSemanticBuildVersionInjectable = getInjectable({
   id: "init-semantic-build-version",
-  instantiate: (di) => {
-    const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
+  instantiate: (di) => ({
+    id: "init-semantic-build-version",
+    run: async () => {
+      const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
 
-    return {
-      id: "init-semantic-build-version",
-      run: () => buildSemanticVersion.init(),
-      runAfter: di.inject(initializeBuildVersionInjectable),
-    };
-  },
+      await buildSemanticVersion.init();
+    },
+    runAfter: di.inject(initializeBuildVersionInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });