Update version of injectable for

- Allow hierarchy of setuppables
- Detection of circular injections
- Detection of circular setuppables
- Better error messages for injecting non-registered injectables
- Introduce injectMany as new pattern
- Introduce keyed singletons as new lifecycle
- Allow instantiation parameter of any type

Adapt to new version of injectable

Remove explicit singleton as lifecycle for being default

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

package.json

@@ -194,8 +194,8 @@
     "@hapi/call": "^8.0.1",
     "@hapi/subtext": "^7.0.3",
     "@kubernetes/client-node": "^0.16.1",
-    "@ogre-tools/injectable": "3.2.1",
+    "@ogre-tools/injectable": "5.0.1",
-    "@ogre-tools/injectable-react": "3.2.1",
+    "@ogre-tools/injectable-react": "5.0.1",
     "@sentry/electron": "^2.5.4",
     "@sentry/integrations": "^6.15.0",
     "@types/circular-dependency-plugin": "5.0.4",

src/common/__tests__/cluster-store.test.ts

@@ -15,7 +15,7 @@ import getCustomKubeConfigDirectoryInjectable from "../app-paths/get-custom-kube
 import clusterStoreInjectable from "../cluster-store/cluster-store.injectable";
 import type { ClusterModel } from "../cluster-types";
 import type {
-  DependencyInjectionContainer,
+  DiContainer,
 } from "@ogre-tools/injectable";
 
 
@@ -75,7 +75,7 @@ jest.mock("electron", () => ({
 }));
 
 describe("cluster-store", () => {
-  let mainDi: DependencyInjectionContainer;
+  let mainDi: DiContainer;
   let clusterStore: ClusterStore;
   let createCluster: (model: ClusterModel) => Cluster;
 

src/common/__tests__/user-store.test.ts

@@ -28,7 +28,7 @@ import electron from "electron";
 import { stdout, stderr } from "process";
 import { getDisForUnitTesting } from "../../test-utils/get-dis-for-unit-testing";
 import userStoreInjectable from "../user-store/user-store.injectable";
-import type { DependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
 import type { ClusterStoreModel } from "../cluster-store/cluster-store";
 import { defaultTheme } from "../vars";
@@ -37,7 +37,7 @@ console = new Console(stdout, stderr);
 
 describe("user store tests", () => {
   let userStore: UserStore;
-  let mainDi: DependencyInjectionContainer;
+  let mainDi: DiContainer;
 
   beforeEach(async () => {
     const dis = getDisForUnitTesting({ doGeneralOverrides: true });

src/common/app-event-bus/app-event-bus.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { appEventBus } from "./event-bus";
 
 const appEventBusInjectable = getInjectable({
+  id: "app-event-bus",
   instantiate: () => appEventBus,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default appEventBusInjectable;

src/common/app-paths/app-path-injection-token.ts

@@ -8,7 +8,7 @@ import { createChannel } from "../ipc-channel/create-channel/create-channel";
 
 export type AppPaths = Record<PathName, string>;
 
-export const appPathsInjectionToken = getInjectionToken<AppPaths>();
+export const appPathsInjectionToken = getInjectionToken<AppPaths>({ id: "app-paths-token" });
 
 export const appPathsIpcChannel = createChannel<AppPaths>("app-paths");
 

src/common/app-paths/app-paths.test.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { DependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 import { AppPaths, appPathsInjectionToken } from "./app-path-injection-token";
 import getElectronAppPathInjectable from "../../main/app-paths/get-electron-app-path/get-electron-app-path.injectable";
 import { getDisForUnitTesting } from "../../test-utils/get-dis-for-unit-testing";
@@ -13,8 +13,8 @@ import directoryForIntegrationTestingInjectable from "../../main/app-paths/direc
 import path from "path";
 
 describe("app-paths", () => {
-  let mainDi: DependencyInjectionContainer;
+  let mainDi: DiContainer;
-  let rendererDi: DependencyInjectionContainer;
+  let rendererDi: DiContainer;
   let runSetups: () => Promise<void[]>;
 
   beforeEach(() => {

src/common/app-paths/directory-for-binaries/directory-for-binaries.injectable.ts

@@ -2,15 +2,15 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import path from "path";
 import directoryForUserDataInjectable from "../directory-for-user-data/directory-for-user-data.injectable";
 
 const directoryForBinariesInjectable = getInjectable({
+  id: "directory-for-binaries",
+
   instantiate: (di) =>
     path.join(di.inject(directoryForUserDataInjectable), "binaries"),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForBinariesInjectable;

src/common/app-paths/directory-for-downloads/directory-for-downloads.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { appPathsInjectionToken } from "../app-path-injection-token";
 
 const directoryForDownloadsInjectable = getInjectable({
+  id: "directory-for-downloads",
   instantiate: (di) => di.inject(appPathsInjectionToken).downloads,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForDownloadsInjectable;

src/common/app-paths/directory-for-exes/directory-for-exes.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { appPathsInjectionToken } from "../app-path-injection-token";
 
 const directoryForExesInjectable = getInjectable({
+  id: "directory-for-exes",
   instantiate: (di) => di.inject(appPathsInjectionToken).exe,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForExesInjectable;

src/common/app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable.ts

@@ -2,15 +2,15 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable from "../directory-for-user-data/directory-for-user-data.injectable";
 import path from "path";
 
 const directoryForKubeConfigsInjectable = getInjectable({
+  id: "directory-for-kube-configs",
+
   instantiate: (di) =>
     path.resolve(di.inject(directoryForUserDataInjectable), "kubeconfigs"),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForKubeConfigsInjectable;

src/common/app-paths/directory-for-temp/directory-for-temp.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { appPathsInjectionToken } from "../app-path-injection-token";
 
 const directoryForTempInjectable = getInjectable({
+  id: "directory-for-temp",
   instantiate: (di) => di.inject(appPathsInjectionToken).temp,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForTempInjectable;

src/common/app-paths/directory-for-user-data/directory-for-user-data.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { appPathsInjectionToken } from "../app-path-injection-token";
 
 const directoryForUserDataInjectable = getInjectable({
+  id: "directory-for-user-data",
   instantiate: (di) => di.inject(appPathsInjectionToken).userData,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForUserDataInjectable;

src/common/app-paths/get-custom-kube-config-directory/get-custom-kube-config-directory.injectable.ts

@@ -2,21 +2,21 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import path from "path";
 import directoryForKubeConfigsInjectable from "../directory-for-kube-configs/directory-for-kube-configs.injectable";
 
 const getCustomKubeConfigDirectoryInjectable = getInjectable({
+  id: "get-custom-kube-config-directory",
+
   instantiate: (di) => (directoryName: string) => {
     const directoryForKubeConfigs = di.inject(directoryForKubeConfigsInjectable);
-    
+
     return path.resolve(
       directoryForKubeConfigs,
       directoryName,
     );
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default getCustomKubeConfigDirectoryInjectable;

src/common/cluster-store/allowed-resources.injectable.ts

@@ -2,11 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { comparer, computed } from "mobx";
 import hostedClusterInjectable from "./hosted-cluster.injectable";
 
 const allowedResourcesInjectable = getInjectable({
+  id: "allowed-resources",
+
   instantiate: (di) => {
     const cluster = di.inject(hostedClusterInjectable);
 
@@ -15,7 +17,6 @@ const allowedResourcesInjectable = getInjectable({
       equals: (cur, prev) => comparer.structural(cur, prev),
     });
   },
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default allowedResourcesInjectable;

src/common/cluster-store/cluster-store.injectable.ts

@@ -2,17 +2,17 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ClusterStore } from "./cluster-store";
 import { createClusterInjectionToken } from "../cluster/create-cluster-injection-token";
 
 const clusterStoreInjectable = getInjectable({
+  id: "cluster-store",
+
   instantiate: (di) =>
     ClusterStore.createInstance({
       createCluster: di.inject(createClusterInjectionToken),
     }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default clusterStoreInjectable;

src/common/cluster-store/hosted-cluster.injectable.ts

@@ -2,18 +2,18 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { getHostedClusterId } from "../utils";
 import clusterStoreInjectable from "./cluster-store.injectable";
 
 const hostedClusterInjectable = getInjectable({
+  id: "hosted-cluster",
+
   instantiate: (di) => {
     const hostedClusterId = getHostedClusterId();
 
     return di.inject(clusterStoreInjectable).getById(hostedClusterId);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default hostedClusterInjectable;

src/common/cluster/authorization-review.injectable.ts

@@ -5,7 +5,7 @@
 
 import { AuthorizationV1Api, KubeConfig, V1ResourceAttributes } from "@kubernetes/client-node";
 import logger from "../logger";
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 
 export type CanI = (resourceAttributes: V1ResourceAttributes) => Promise<boolean>;
 
@@ -38,8 +38,8 @@ export function authorizationReview(proxyConfig: KubeConfig): CanI {
 }
 
 const authorizationReviewInjectable = getInjectable({
+  id: "authorization-review",
   instantiate: () => authorizationReview,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default authorizationReviewInjectable;

src/common/cluster/create-cluster-injection-token.ts

@@ -7,4 +7,4 @@ import type { ClusterModel } from "../cluster-types";
 import type { Cluster } from "./cluster";
 
 export const createClusterInjectionToken =
-  getInjectionToken<(model: ClusterModel) => Cluster>();
+  getInjectionToken<(model: ClusterModel) => Cluster>({ id: "create-cluster-token" });

src/common/cluster/list-namespaces.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { CoreV1Api, KubeConfig } from "@kubernetes/client-node";
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 
 export type ListNamespaces = () => Promise<string[]>;
 
@@ -18,8 +18,8 @@ export function listNamespaces(config: KubeConfig): ListNamespaces {
 }
 
 const listNamespacesInjectable = getInjectable({
+  id: "list-namespaces",
   instantiate: () => listNamespaces,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default listNamespacesInjectable;

src/common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable.ts

@@ -2,18 +2,18 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import path from "path";
 import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
 
 const directoryForLensLocalStorageInjectable = getInjectable({
+  id: "directory-for-lens-local-storage",
+
   instantiate: (di) =>
     path.resolve(
       di.inject(directoryForUserDataInjectable),
       "lens-local-storage",
     ),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForLensLocalStorageInjectable;

src/common/fs/fs.injectable.ts

@@ -2,13 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import fse from "fs-extra";
 
 const fsInjectable = getInjectable({
+  id: "fs",
   instantiate: () => fse,
   causesSideEffects: true,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default fsInjectable;

src/common/fs/read-dir.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import fsInjectable from "./fs.injectable";
 
 const readDirInjectable = getInjectable({
+  id: "read-dir",
   instantiate: (di) => di.inject(fsInjectable).readdir,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default readDirInjectable;

src/common/fs/read-file.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import fsInjectable from "./fs.injectable";
 
 const readFileInjectable = getInjectable({
+  id: "read-file",
   instantiate: (di) => di.inject(fsInjectable).readFile,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default readFileInjectable;

src/common/fs/read-json-file.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import fsInjectable from "./fs.injectable";
 
 const readJsonFileInjectable = getInjectable({
+  id: "read-json-file",
   instantiate: (di) => di.inject(fsInjectable).readJson,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default readJsonFileInjectable;

src/common/fs/write-json-file.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import type { EnsureOptions, WriteOptions } from "fs-extra";
 import path from "path";
 import type { JsonValue } from "type-fest";
@@ -23,6 +23,8 @@ const writeJsonFile = ({ writeJson, ensureDir }: Dependencies) => async (filePat
 };
 
 const writeJsonFileInjectable = getInjectable({
+  id: "write-json-file",
+
   instantiate: (di) => {
     const { writeJson, ensureDir } = di.inject(fsInjectable);
 
@@ -31,8 +33,6 @@ const writeJsonFileInjectable = getInjectable({
       ensureDir,
     });
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default writeJsonFileInjectable;

src/common/hotbar-store.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { HotbarStore } from "./hotbar-store";
 
 const hotbarManagerInjectable = getInjectable({
+  id: "hotbar-manager",
   instantiate: () => HotbarStore.getInstance(),
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default hotbarManagerInjectable;

src/common/user-store/user-store.injectable.ts

@@ -2,13 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { UserStore } from "./user-store";
 
 const userStoreInjectable = getInjectable({
+  id: "user-store",
   instantiate: () => UserStore.createInstance(),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default userStoreInjectable;

src/common/utils/is-allowed-resource.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import allowedResourcesInjectable from "../cluster-store/allowed-resources.injectable";
 import type { KubeResource } from "../rbac";
 
@@ -10,13 +10,13 @@ export type IsAllowedResource = (resource: KubeResource) => boolean;
 
 // TODO: This injectable obscures MobX de-referencing. Make it more apparent in usage.
 const isAllowedResourceInjectable = getInjectable({
+  id: "is-allowed-resource",
+
   instantiate: (di) => {
     const allowedResources = di.inject(allowedResourcesInjectable);
 
     return (resource: KubeResource) => allowedResources.get().has(resource);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default isAllowedResourceInjectable;

src/common/vars/is-linux.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { isLinux } from "../vars";
 
 const isLinuxInjectable = getInjectable({
+  id: "is-linux",
   instantiate: () => isLinux,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default isLinuxInjectable;

src/common/vars/is-windows.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { isWindows } from "../vars";
 
 const isWindowsInjectable = getInjectable({
+  id: "is-windows",
   instantiate: () => isWindows,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default isWindowsInjectable;

src/extensions/as-legacy-globals-for-extension-api/as-legacy-global-function-for-extension-api.ts

@@ -2,12 +2,10 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import type { Injectable, TentativeTuple } from "@ogre-tools/injectable";
 
 import { getLegacyGlobalDiForExtensionApi } from "./legacy-global-di-for-extension-api";
 
-type TentativeTuple<T> = T extends object ? [T] : [undefined?];
-
 type FactoryType = <
   TInjectable extends Injectable<unknown, TInstance, TInstantiationParameter>,
   TInstantiationParameter,

src/extensions/as-legacy-globals-for-extension-api/as-legacy-global-object-for-extension-api-with-modifications.ts

@@ -2,11 +2,9 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import type { Injectable, TentativeTuple } from "@ogre-tools/injectable";
 import { getLegacyGlobalDiForExtensionApi } from "./legacy-global-di-for-extension-api";
 
-type TentativeTuple<T> = T extends object ? [T] : [undefined?];
-
 type MapInjectables<T> = {
   [Key in keyof T]: T[Key] extends () => infer Res ? Res : never;
 };

src/extensions/as-legacy-globals-for-extension-api/as-legacy-global-object-for-extension-api.ts

@@ -2,11 +2,9 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { Injectable } from "@ogre-tools/injectable";
+import type { Injectable, TentativeTuple } from "@ogre-tools/injectable";
 import { getLegacyGlobalDiForExtensionApi } from "./legacy-global-di-for-extension-api";
 
-type TentativeTuple<T> = T extends object ? [T] : [undefined?];
-
 export const asLegacyGlobalObjectForExtensionApi = <
   TInjectable extends Injectable<unknown, unknown, TInstantiationParameter>,
   TInstantiationParameter,

src/extensions/as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api.ts

@@ -2,11 +2,11 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { DependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 
-let legacyGlobalDi: DependencyInjectionContainer;
+let legacyGlobalDi: DiContainer;
 
-export const setLegacyGlobalDiForExtensionApi = (di: DependencyInjectionContainer) => {
+export const setLegacyGlobalDiForExtensionApi = (di: DiContainer) => {
   legacyGlobalDi = di;
 };
 

src/extensions/common-api/get-enabled-extensions/get-enabled-extensions.injectable.ts

@@ -2,14 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import extensionsStoreInjectable from "../../extensions-store/extensions-store.injectable";
 
 const getEnabledExtensionsInjectable = getInjectable({
+  id: "get-enabled-extensions",
+
   instantiate: (di) => () =>
     di.inject(extensionsStoreInjectable).enabledExtensions,
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default getEnabledExtensionsInjectable;

src/extensions/extension-discovery/extension-discovery.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ExtensionDiscovery } from "./extension-discovery";
 import extensionLoaderInjectable from "../extension-loader/extension-loader.injectable";
 import isCompatibleExtensionInjectable from "./is-compatible-extension/is-compatible-extension.injectable";
@@ -14,6 +14,8 @@ import extensionPackageRootDirectoryInjectable from "../extension-installer/exte
 import installExtensionsInjectable from "../extension-installer/install-extensions/install-extensions.injectable";
 
 const extensionDiscoveryInjectable = getInjectable({
+  id: "extension-discovery",
+
   instantiate: (di) =>
     new ExtensionDiscovery({
       extensionLoader: di.inject(extensionLoaderInjectable),
@@ -36,8 +38,6 @@ const extensionDiscoveryInjectable = getInjectable({
         extensionPackageRootDirectoryInjectable,
       ),
     }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default extensionDiscoveryInjectable;

src/extensions/extension-discovery/is-compatible-bundled-extension/is-compatible-bundled-extension.injectable.ts

@@ -2,13 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { appSemVer } from "../../../common/vars";
 import { isCompatibleBundledExtension } from "./is-compatible-bundled-extension";
 
 const isCompatibleBundledExtensionInjectable = getInjectable({
+  id: "is-compatible-bundled-extension",
   instantiate: () => isCompatibleBundledExtension({ appSemVer }),
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default isCompatibleBundledExtensionInjectable;

src/extensions/extension-discovery/is-compatible-extension/is-compatible-extension.injectable.ts

@@ -2,13 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { appSemVer } from "../../../common/vars";
 import { isCompatibleExtension } from "./is-compatible-extension";
 
 const isCompatibleExtensionInjectable = getInjectable({
+  id: "is-compatible-extension",
   instantiate: () => isCompatibleExtension({ appSemVer }),
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default isCompatibleExtensionInjectable;

src/extensions/extension-installation-state-store/extension-installation-state-store.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ExtensionInstallationStateStore } from "./extension-installation-state-store";
 
 const extensionInstallationStateStoreInjectable = getInjectable({
+  id: "extension-installation-state-store",
   instantiate: () => new ExtensionInstallationStateStore(),
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default extensionInstallationStateStoreInjectable;

src/extensions/extension-installer/extension-installer.injectable.ts

@@ -2,19 +2,19 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ExtensionInstaller } from "./extension-installer";
 import extensionPackageRootDirectoryInjectable from "./extension-package-root-directory/extension-package-root-directory.injectable";
 
 const extensionInstallerInjectable = getInjectable({
+  id: "extension-installer",
+
   instantiate: (di) =>
     new ExtensionInstaller({
       extensionPackageRootDirectory: di.inject(
         extensionPackageRootDirectoryInjectable,
       ),
     }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default extensionInstallerInjectable;

src/extensions/extension-installer/extension-package-root-directory/extension-package-root-directory.injectable.ts

@@ -2,14 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable
   from "../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
 
 const extensionPackageRootDirectoryInjectable = getInjectable({
-  instantiate: (di) => di.inject(directoryForUserDataInjectable),
+  id: "extension-package-root-directory",
 
-  lifecycle: lifecycleEnum.singleton,
+  instantiate: (di) => di.inject(directoryForUserDataInjectable),
 });
 
 export default extensionPackageRootDirectoryInjectable;

src/extensions/extension-installer/install-extension/install-extension.injectable.ts

@@ -2,13 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import extensionInstallerInjectable from "../extension-installer.injectable";
 
 const installExtensionInjectable = getInjectable({
+  id: "install-extension",
   instantiate: (di) => di.inject(extensionInstallerInjectable).installPackage,
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default installExtensionInjectable;

src/extensions/extension-installer/install-extensions/install-extensions.injectable.ts

@@ -2,13 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import extensionInstallerInjectable from "../extension-installer.injectable";
 
 const installExtensionsInjectable = getInjectable({
+  id: "install-extensions",
   instantiate: (di) => di.inject(extensionInstallerInjectable).installPackages,
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default installExtensionsInjectable;

src/extensions/extension-loader/create-extension-instance/create-extension-instance.injectable.ts

@@ -2,16 +2,16 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { createExtensionInstance } from "./create-extension-instance";
 import fileSystemProvisionerStoreInjectable from "./file-system-provisioner-store/file-system-provisioner-store.injectable";
 
 const createExtensionInstanceInjectable = getInjectable({
+  id: "create-extension-instance",
+
   instantiate: (di) => createExtensionInstance({
     fileSystemProvisionerStore: di.inject(fileSystemProvisionerStoreInjectable),
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default createExtensionInstanceInjectable;

src/extensions/extension-loader/create-extension-instance/file-system-provisioner-store/directory-for-extension-data/directory-for-extension-data.injectable.ts

@@ -2,15 +2,15 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import path from "path";
 import directoryForUserDataInjectable from "../../../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
 
 const directoryForExtensionDataInjectable = getInjectable({
+  id: "directory-for-extension-data",
+
   instantiate: (di) =>
     path.join(di.inject(directoryForUserDataInjectable), "extension_data"),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForExtensionDataInjectable;

src/extensions/extension-loader/create-extension-instance/file-system-provisioner-store/file-system-provisioner-store.injectable.ts

@@ -2,19 +2,19 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { FileSystemProvisionerStore } from "./file-system-provisioner-store";
 import directoryForExtensionDataInjectable from "./directory-for-extension-data/directory-for-extension-data.injectable";
 
 const fileSystemProvisionerStoreInjectable = getInjectable({
+  id: "file-system-provisioner-store",
+
   instantiate: (di) =>
     FileSystemProvisionerStore.createInstance({
       directoryForExtensionData: di.inject(
         directoryForExtensionDataInjectable,
       ),
     }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default fileSystemProvisionerStoreInjectable;

src/extensions/extension-loader/extension-loader.injectable.ts

@@ -2,20 +2,20 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ExtensionLoader } from "./extension-loader";
 import updateExtensionsStateInjectable from "./update-extensions-state/update-extensions-state.injectable";
 import createExtensionInstanceInjectable
   from "./create-extension-instance/create-extension-instance.injectable";
 
 const extensionLoaderInjectable = getInjectable({
+  id: "extension-loader",
+
   instantiate: (di) =>
     new ExtensionLoader({
       updateExtensionsState: di.inject(updateExtensionsStateInjectable),
       createExtensionInstance: di.inject(createExtensionInstanceInjectable),
     }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default extensionLoaderInjectable;

src/extensions/extension-loader/update-extensions-state/update-extensions-state.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import extensionsStoreInjectable from "../../extensions-store/extensions-store.injectable";
 
 const updateExtensionsStateInjectable = getInjectable({
+  id: "upadte-extensions-state",
   instantiate: (di) => di.inject(extensionsStoreInjectable).mergeState,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default updateExtensionsStateInjectable;

src/extensions/extension-packages-root/extension-packages-root.injectable.ts

@@ -2,13 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable
   from "../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
 
 const extensionPackagesRootInjectable = getInjectable({
+  id: "extension-packages-root",
   instantiate: (di) => di.inject(directoryForUserDataInjectable),
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default extensionPackagesRootInjectable;

src/extensions/extensions-store/extensions-store.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ExtensionsStore } from "./extensions-store";
 
 const extensionsStoreInjectable = getInjectable({
+  id: "extensions-store",
   instantiate: () => ExtensionsStore.createInstance(),
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default extensionsStoreInjectable;

src/extensions/extensions.injectable.ts

@@ -2,18 +2,18 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { computed } from "mobx";
 import extensionLoaderInjectable from "./extension-loader/extension-loader.injectable";
 
 const extensionsInjectable = getInjectable({
+  id: "extensions",
+
   instantiate: (di) => {
     const extensionLoader = di.inject(extensionLoaderInjectable);
 
     return computed(() => extensionLoader.enabledExtensionInstances);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default extensionsInjectable;

src/extensions/main-extensions.injectable.ts

@@ -2,13 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import type { IComputedValue } from "mobx";
 import extensionsInjectable from "./extensions.injectable";
 import type { LensMainExtension } from "./lens-main-extension";
 
 const mainExtensionsInjectable = getInjectable({
-  lifecycle: lifecycleEnum.singleton,
+  id: "main-extensions",
 
   instantiate: (di) =>
     di.inject(extensionsInjectable) as IComputedValue<LensMainExtension[]>,

src/extensions/renderer-extensions.injectable.ts

@@ -2,14 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import type { IComputedValue } from "mobx";
 import extensionsInjectable from "./extensions.injectable";
 import type { LensRendererExtension } from "./lens-renderer-extension";
 
 const rendererExtensionsInjectable = getInjectable({
+  id: "renderer-extensions",
   instantiate: (di) => di.inject(extensionsInjectable) as IComputedValue<LensRendererExtension[]>,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default rendererExtensionsInjectable;

src/main/app-paths/app-name/app-name.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import electronAppInjectable from "../get-electron-app-path/electron-app/electron-app.injectable";
 
 const appNameInjectable = getInjectable({
+  id: "app-name",
   instantiate: (di) => di.inject(electronAppInjectable).name,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default appNameInjectable;

src/main/app-paths/app-paths.injectable.ts

@@ -3,9 +3,8 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import {
-  DependencyInjectionContainer,
+  DiContainerForSetup,
   getInjectable,
-  lifecycleEnum,
 } from "@ogre-tools/injectable";
 
 import {
@@ -22,38 +21,40 @@ import appNameInjectable from "./app-name/app-name.injectable";
 import directoryForIntegrationTestingInjectable from "./directory-for-integration-testing/directory-for-integration-testing.injectable";
 
 const appPathsInjectable = getInjectable({
-  setup: (di) => {
+  id: "app-paths",
-    const directoryForIntegrationTesting = di.inject(
+
+  setup: async (di) => {
+    const directoryForIntegrationTesting = await di.inject(
       directoryForIntegrationTestingInjectable,
     );
 
     if (directoryForIntegrationTesting) {
-      setupPathForAppDataInIntegrationTesting(di, directoryForIntegrationTesting);
+      await setupPathForAppDataInIntegrationTesting(di, directoryForIntegrationTesting);
     }
 
-    setupPathForUserData(di);
+    await setupPathForUserData(di);
-    registerAppPathsChannel(di);
+    await registerAppPathsChannel(di);
   },
 
   instantiate: (di) =>
     getAppPaths({ getAppPath: di.inject(getElectronAppPathInjectable) }),
 
   injectionToken: appPathsInjectionToken,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default appPathsInjectable;
 
-const registerAppPathsChannel = (di: DependencyInjectionContainer) => {
+const registerAppPathsChannel = async (di: DiContainerForSetup) => {
-  const registerChannel = di.inject(registerChannelInjectable);
+  const registerChannel = await di.inject(registerChannelInjectable);
+  const appPaths = await di.inject(appPathsInjectable);
 
-  registerChannel(appPathsIpcChannel, () => di.inject(appPathsInjectable));
+  registerChannel(appPathsIpcChannel, () => appPaths);
 };
 
-const setupPathForUserData = (di: DependencyInjectionContainer) => {
+const setupPathForUserData = async (di: DiContainerForSetup) => {
-  const setElectronAppPath = di.inject(setElectronAppPathInjectable);
+  const setElectronAppPath = await di.inject(setElectronAppPathInjectable);
-  const appName = di.inject(appNameInjectable);
+  const appName = await di.inject(appNameInjectable);
-  const getAppPath = di.inject(getElectronAppPathInjectable);
+  const getAppPath = await di.inject(getElectronAppPathInjectable);
 
   const appDataPath = getAppPath("appData");
 
@@ -61,8 +62,8 @@ const setupPathForUserData = (di: DependencyInjectionContainer) => {
 };
 
 // Todo: this kludge is here only until we have a proper place to setup integration testing.
-const setupPathForAppDataInIntegrationTesting = (di: DependencyInjectionContainer, appDataPath: string) => {
+const setupPathForAppDataInIntegrationTesting = async (di: DiContainerForSetup, appDataPath: string) => {
-  const setElectronAppPath = di.inject(setElectronAppPathInjectable);
+  const setElectronAppPath = await di.inject(setElectronAppPathInjectable);
 
   setElectronAppPath("appData", appDataPath);
 };

src/main/app-paths/directory-for-integration-testing/directory-for-integration-testing.injectable.ts

@@ -2,11 +2,11 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 
 const directoryForIntegrationTestingInjectable = getInjectable({
+  id: "directory-for-integration-testing",
   instantiate: () => process.env.CICD,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForIntegrationTestingInjectable;

src/main/app-paths/get-electron-app-path/electron-app/electron-app.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { app } from "electron";
 
 const electronAppInjectable = getInjectable({
+  id: "electron-app",
   instantiate: () => app,
-  lifecycle: lifecycleEnum.singleton,
   causesSideEffects: true,
 });
 

src/main/app-paths/get-electron-app-path/get-electron-app-path.injectable.ts

@@ -2,15 +2,15 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import electronAppInjectable from "./electron-app/electron-app.injectable";
 import { getElectronAppPath } from "./get-electron-app-path";
 
 const getElectronAppPathInjectable = getInjectable({
+  id: "get-electron-app-path",
+
   instantiate: (di) =>
     getElectronAppPath({ app: di.inject(electronAppInjectable) }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default getElectronAppPathInjectable;

src/main/app-paths/register-channel/ipc-main/ipc-main.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ipcMain } from "electron";
 
 const ipcMainInjectable = getInjectable({
+  id: "ipc-main",
   instantiate: () => ipcMain,
-  lifecycle: lifecycleEnum.singleton,
   causesSideEffects: true,
 });
 

src/main/app-paths/register-channel/register-channel.injectable.ts

@@ -2,16 +2,16 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import ipcMainInjectable from "./ipc-main/ipc-main.injectable";
 import { registerChannel } from "./register-channel";
 
 const registerChannelInjectable = getInjectable({
+  id: "register-channel",
+
   instantiate: (di) => registerChannel({
     ipcMain: di.inject(ipcMainInjectable),
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default registerChannelInjectable;

src/main/app-paths/set-electron-app-path/set-electron-app-path.injectable.ts

@@ -2,15 +2,15 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import type { PathName } from "../../../common/app-paths/app-path-names";
 import electronAppInjectable from "../get-electron-app-path/electron-app/electron-app.injectable";
 
 const setElectronAppPathInjectable = getInjectable({
+  id: "set-electron-app-path",
+
   instantiate: (di) => (name: PathName, path: string) : void =>
     di.inject(electronAppInjectable).setPath(name, path),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default setElectronAppPathInjectable;

src/main/catalog-sources/kubeconfig-sync-manager/kubeconfig-sync-manager.injectable.ts

@@ -2,18 +2,18 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import directoryForKubeConfigsInjectable from "../../../common/app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
 import { KubeconfigSyncManager } from "./kubeconfig-sync-manager";
 import { createClusterInjectionToken } from "../../../common/cluster/create-cluster-injection-token";
 
 const kubeconfigSyncManagerInjectable = getInjectable({
+  id: "kubeconfig-sync-manager",
+
   instantiate: (di) => new KubeconfigSyncManager({
     directoryForKubeConfigs: di.inject(directoryForKubeConfigsInjectable),
     createCluster: di.inject(createClusterInjectionToken),
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default kubeconfigSyncManagerInjectable;

src/main/context-handler/create-context-handler.injectable.ts

@@ -2,12 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import type { Cluster } from "../../common/cluster/cluster";
 import { ContextHandler } from "./context-handler";
 import createKubeAuthProxyInjectable from "../kube-auth-proxy/create-kube-auth-proxy.injectable";
 
 const createContextHandlerInjectable = getInjectable({
+  id: "create-context-handler",
+
   instantiate: (di) => {
     const dependencies = {
       createKubeAuthProxy: di.inject(createKubeAuthProxyInjectable),
@@ -15,8 +17,6 @@ const createContextHandlerInjectable = getInjectable({
 
     return (cluster: Cluster) => new ContextHandler(dependencies, cluster);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default createContextHandlerInjectable;

src/main/create-cluster/create-cluster.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { Cluster, ClusterDependencies } from "../../common/cluster/cluster";
 import directoryForKubeConfigsInjectable from "../../common/app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
 import createKubeconfigManagerInjectable from "../kubeconfig-manager/create-kubeconfig-manager.injectable";
@@ -13,6 +13,8 @@ import authorizationReviewInjectable from "../../common/cluster/authorization-re
 import listNamespacesInjectable from "../../common/cluster/list-namespaces.injectable";
 
 const createClusterInjectable = getInjectable({
+  id: "create-cluster",
+
   instantiate: (di) => {
     const dependencies: ClusterDependencies = {
       directoryForKubeConfigs: di.inject(directoryForKubeConfigsInjectable),
@@ -27,8 +29,6 @@ const createClusterInjectable = getInjectable({
   },
 
   injectionToken: createClusterInjectionToken,
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default createClusterInjectable;

src/main/getDiForUnitTesting.ts

@@ -27,7 +27,6 @@ export const getDiForUnitTesting = (
     const injectableInstance = require(filePath).default;
 
     di.register({
-      id: filePath,
       ...injectableInstance,
       aliases: [injectableInstance, ...(injectableInstance.aliases || [])],
     });

src/main/initializers/init-ipc-main-handlers/init-ipc-main-handlers.injectable.ts

@@ -2,19 +2,19 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import electronMenuItemsInjectable from "../../menu/electron-menu-items.injectable";
 import directoryForLensLocalStorageInjectable
   from "../../../common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable";
 import { initIpcMainHandlers } from "./init-ipc-main-handlers";
 
 const initIpcMainHandlersInjectable = getInjectable({
+  id: "init-ipc-main-handlers",
+
   instantiate: (di) => initIpcMainHandlers({
     electronMenuItems: di.inject(electronMenuItemsInjectable),
     directoryForLensLocalStorage: di.inject(directoryForLensLocalStorageInjectable),
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default initIpcMainHandlersInjectable;

src/main/kube-auth-proxy/create-kube-auth-proxy.injectable.ts

@@ -2,12 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { KubeAuthProxy } from "./kube-auth-proxy";
 import type { Cluster } from "../../common/cluster/cluster";
 import bundledKubectlInjectable from "../kubectl/bundled-kubectl.injectable";
 
 const createKubeAuthProxyInjectable = getInjectable({
+  id: "create-kube-auth-proxy",
+
   instantiate: (di) => {
     const bundledKubectl = di.inject(bundledKubectlInjectable);
 
@@ -18,8 +20,6 @@ const createKubeAuthProxyInjectable = getInjectable({
     return (cluster: Cluster, environmentVariables: NodeJS.ProcessEnv) =>
       new KubeAuthProxy(dependencies, cluster, environmentVariables);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default createKubeAuthProxyInjectable;

src/main/kubeconfig-manager/create-kubeconfig-manager.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import type { Cluster } from "../../common/cluster/cluster";
 import directoryForTempInjectable from "../../common/app-paths/directory-for-temp/directory-for-temp.injectable";
 import { KubeconfigManager } from "./kubeconfig-manager";
@@ -12,6 +12,8 @@ export interface KubeConfigManagerInstantiationParameter {
 }
 
 const createKubeconfigManagerInjectable = getInjectable({
+  id: "create-kubeconfig-manager",
+
   instantiate: (di) => {
     const dependencies = {
       directoryForTemp: di.inject(directoryForTempInjectable),
@@ -19,8 +21,6 @@ const createKubeconfigManagerInjectable = getInjectable({
 
     return (cluster: Cluster) => new KubeconfigManager(dependencies, cluster);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default createKubeconfigManagerInjectable;

src/main/kubectl/bundled-kubectl.injectable.ts

@@ -2,11 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { getBundledKubectlVersion } from "../../common/utils";
 import createKubectlInjectable from "./create-kubectl.injectable";
 
 const bundledKubectlInjectable = getInjectable({
+  id: "bundled-kubectl",
+
   instantiate: (di) => {
     const createKubectl = di.inject(createKubectlInjectable);
 
@@ -14,8 +16,6 @@ const bundledKubectlInjectable = getInjectable({
 
     return createKubectl(bundledKubectlVersion);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default bundledKubectlInjectable;

src/main/kubectl/create-kubectl.injectable.ts

@@ -2,12 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { Kubectl } from "./kubectl";
 import directoryForKubectlBinariesInjectable from "./directory-for-kubectl-binaries/directory-for-kubectl-binaries.injectable";
 import userStoreInjectable from "../../common/user-store/user-store.injectable";
 
 const createKubectlInjectable = getInjectable({
+  id: "create-kubectl",
+
   instantiate: (di) => {
     const dependencies = {
       userStore: di.inject(userStoreInjectable),
@@ -20,8 +22,6 @@ const createKubectlInjectable = getInjectable({
     return (clusterVersion: string) =>
       new Kubectl(dependencies, clusterVersion);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default createKubectlInjectable;

src/main/kubectl/directory-for-kubectl-binaries/directory-for-kubectl-binaries.injectable.ts

@@ -2,15 +2,15 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import directoryForBinariesInjectable from "../../../common/app-paths/directory-for-binaries/directory-for-binaries.injectable";
 import path from "path";
 
 const directoryForKubectlBinariesInjectable = getInjectable({
+  id: "directory-for-kubectl-binaries",
+
   instantiate: (di) =>
     path.join(di.inject(directoryForBinariesInjectable), "kubectl"),
-  
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default directoryForKubectlBinariesInjectable;

src/main/menu/electron-menu-items.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { computed } from "mobx";
 import mainExtensionsInjectable from "../../extensions/main-extensions.injectable";
 
 const electronMenuItemsInjectable = getInjectable({
-  lifecycle: lifecycleEnum.singleton,
+  id: "electron-menu-items",
 
   instantiate: (di) => {
     const extensions = di.inject(mainExtensionsInjectable);

src/main/menu/electron-menu-items.test.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { ConfigurableDependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 import { LensMainExtension } from "../../extensions/lens-main-extension";
 import electronMenuItemsInjectable from "./electron-menu-items.injectable";
 import type { IComputedValue } from "mobx";
@@ -12,7 +12,7 @@ import { getDiForUnitTesting } from "../getDiForUnitTesting";
 import mainExtensionsInjectable from "../../extensions/main-extensions.injectable";
 
 describe("electron-menu-items", () => {
-  let di: ConfigurableDependencyInjectionContainer;
+  let di: DiContainer;
   let electronMenuItems: IComputedValue<MenuRegistration[]>;
   let extensionsStub: ObservableMap<string, LensMainExtension>;
 

src/main/protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable.ts

@@ -2,19 +2,19 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import extensionLoaderInjectable from "../../../extensions/extension-loader/extension-loader.injectable";
 import { LensProtocolRouterMain } from "./lens-protocol-router-main";
 import extensionsStoreInjectable from "../../../extensions/extensions-store/extensions-store.injectable";
 
 const lensProtocolRouterMainInjectable = getInjectable({
+  id: "lens-protocol-router-main",
+
   instantiate: (di) =>
     new LensProtocolRouterMain({
       extensionLoader: di.inject(extensionLoaderInjectable),
       extensionsStore: di.inject(extensionsStoreInjectable),
     }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default lensProtocolRouterMainInjectable;

src/main/proxy-functions/shell-api-request/shell-api-request.injectable.ts

@@ -2,19 +2,19 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { shellApiRequest } from "./shell-api-request";
 import createShellSessionInjectable from "../../shell-session/create-shell-session.injectable";
 import shellRequestAuthenticatorInjectable
   from "./shell-request-authenticator/shell-request-authenticator.injectable";
 
 const shellApiRequestInjectable = getInjectable({
+  id: "shell-api-request",
+
   instantiate: (di) => shellApiRequest({
     createShellSession: di.inject(createShellSessionInjectable),
     authenticateRequest: di.inject(shellRequestAuthenticatorInjectable).authenticate,
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default shellApiRequestInjectable;

src/main/proxy-functions/shell-api-request/shell-request-authenticator/shell-request-authenticator.injectable.ts

@@ -2,10 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ShellRequestAuthenticator } from "./shell-request-authenticator";
 
 const shellRequestAuthenticatorInjectable = getInjectable({
+  id: "shell-request-authenticator",
+
   instantiate: () => {
     const authenticator = new ShellRequestAuthenticator();
 
@@ -13,8 +15,6 @@ const shellRequestAuthenticatorInjectable = getInjectable({
 
     return authenticator;
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default shellRequestAuthenticatorInjectable;

src/main/router/router.injectable.ts

@@ -2,17 +2,17 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { Router } from "../router";
 import routePortForwardInjectable
   from "../routes/port-forward/route-port-forward/route-port-forward.injectable";
 
 const routerInjectable = getInjectable({
+  id: "router",
+
   instantiate: (di) => new Router({
     routePortForward: di.inject(routePortForwardInjectable),
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default routerInjectable;

src/main/routes/port-forward/create-port-forward.injectable.ts

@@ -2,11 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { PortForward, PortForwardArgs } from "./port-forward";
 import bundledKubectlInjectable from "../../kubectl/bundled-kubectl.injectable";
 
 const createPortForwardInjectable = getInjectable({
+  id: "create-port-forward",
+
   instantiate: (di) => {
     const bundledKubectl = di.inject(bundledKubectlInjectable);
 
@@ -17,8 +19,6 @@ const createPortForwardInjectable = getInjectable({
     return (pathToKubeConfig: string, args: PortForwardArgs) =>
       new PortForward(dependencies, pathToKubeConfig, args);
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default createPortForwardInjectable;

src/main/routes/port-forward/route-port-forward/route-port-forward.injectable.ts

@@ -3,15 +3,15 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { routePortForward } from "./route-port-forward";
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import createPortForwardInjectable from "../create-port-forward.injectable";
 
 const routePortForwardInjectable = getInjectable({
+  id: "route-port-forward",
+
   instantiate: (di) => routePortForward({
     createPortForward: di.inject(createPortForwardInjectable),
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default routePortForwardInjectable;

src/main/shell-session/create-shell-session.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import type { Cluster } from "../../common/cluster/cluster";
 import type WebSocket from "ws";
 import localShellSessionInjectable from "./local-shell-session/local-shell-session.injectable";
@@ -16,14 +16,14 @@ interface Args {
 }
 
 const createShellSessionInjectable = getInjectable({
+  id: "create-shell-session",
+
   instantiate:
     (di) =>
       ({ nodeName, ...rest }: Args) =>
         !nodeName
           ? di.inject(localShellSessionInjectable, rest)
           : di.inject(nodeShellSessionInjectable, { nodeName, ...rest }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default createShellSessionInjectable;

src/main/shell-session/local-shell-session/local-shell-session.injectable.ts

@@ -16,6 +16,8 @@ interface InstantiationParameter {
 }
 
 const localShellSessionInjectable = getInjectable({
+  id: "local-shell-session",
+
   instantiate: (di, { cluster, tabId, webSocket }: InstantiationParameter) => {
     const createKubectl = di.inject(createKubectlInjectable);
     const localShellEnvModify = di.inject(terminalShellEnvModifiersInjectable);

src/main/shell-session/node-shell-session/node-shell-session.injectable.ts

@@ -16,6 +16,8 @@ interface InstantiationParameter {
 }
 
 const nodeShellSessionInjectable = getInjectable({
+  id: "node-shell-session",
+
   instantiate: (di, { cluster, tabId, webSocket, nodeName }: InstantiationParameter) => {
     const createKubectl = di.inject(createKubectlInjectable);
 

src/main/shell-session/shell-env-modifier/terminal-shell-env-modify.injectable.ts

@@ -6,14 +6,16 @@
 import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import mainExtensionsInjectable from "../../../extensions/main-extensions.injectable";
 import { terminalShellEnvModify } from "./terminal-shell-env-modifiers";
- 
+
 const terminalShellEnvModifyInjectable = getInjectable({
+  id: "terminal-shell-env-modify",
+
   instantiate: (di) =>
     terminalShellEnvModify({
       extensions: di.inject(mainExtensionsInjectable),
     }),
- 
+
   lifecycle: lifecycleEnum.singleton,
 });
- 
+
 export default terminalShellEnvModifyInjectable;

src/main/tray/tray-menu-items.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { computed } from "mobx";
 import mainExtensionsInjectable from "../../extensions/main-extensions.injectable";
 
 const trayItemsInjectable = getInjectable({
-  lifecycle: lifecycleEnum.singleton,
+  id: "tray-items",
 
   instantiate: (di) => {
     const extensions = di.inject(mainExtensionsInjectable);

src/main/tray/tray-menu-items.test.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { ConfigurableDependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 import { LensMainExtension } from "../../extensions/lens-main-extension";
 import trayItemsInjectable from "./tray-menu-items.injectable";
 import type { IComputedValue } from "mobx";
@@ -12,7 +12,7 @@ import mainExtensionsInjectable from "../../extensions/main-extensions.injectabl
 import type { TrayMenuRegistration } from "./tray-menu-registration";
 
 describe("tray-menu-items", () => {
-  let di: ConfigurableDependencyInjectionContainer;
+  let di: DiContainer;
   let trayMenuItems: IComputedValue<TrayMenuRegistration[]>;
   let extensionsStub: ObservableMap<string, LensMainExtension>;
 

src/renderer/api/catalog-entity-registry/catalog-entity-registry.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { catalogEntityRegistry } from "../catalog-entity-registry";
 
 const catalogEntityRegistryInjectable = getInjectable({
+  id: "catalog-entity-registry",
   instantiate: () => catalogEntityRegistry,
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default catalogEntityRegistryInjectable;

src/renderer/app-paths/app-paths.injectable.ts

@@ -2,15 +2,17 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { AppPaths, appPathsInjectionToken, appPathsIpcChannel } from "../../common/app-paths/app-path-injection-token";
 import getValueFromRegisteredChannelInjectable from "./get-value-from-registered-channel/get-value-from-registered-channel.injectable";
 
 let syncAppPaths: AppPaths;
 
 const appPathsInjectable = getInjectable({
+  id: "app-paths",
+
   setup: async (di) => {
-    const getValueFromRegisteredChannel = di.inject(
+    const getValueFromRegisteredChannel = await di.inject(
       getValueFromRegisteredChannelInjectable,
     );
 
@@ -20,8 +22,6 @@ const appPathsInjectable = getInjectable({
   instantiate: () => syncAppPaths,
 
   injectionToken: appPathsInjectionToken,
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default appPathsInjectable;

src/renderer/app-paths/get-value-from-registered-channel/get-value-from-registered-channel.injectable.ts

@@ -2,15 +2,15 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import ipcRendererInjectable from "./ipc-renderer/ipc-renderer.injectable";
 import { getValueFromRegisteredChannel } from "./get-value-from-registered-channel";
 
 const getValueFromRegisteredChannelInjectable = getInjectable({
+  id: "get-value-from-registered-channel",
+
   instantiate: (di) =>
     getValueFromRegisteredChannel({ ipcRenderer: di.inject(ipcRendererInjectable) }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default getValueFromRegisteredChannelInjectable;

src/renderer/app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable.ts

@@ -2,12 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ipcRenderer } from "electron";
 
 const ipcRendererInjectable = getInjectable({
+  id: "ipc-renderer",
   instantiate: () => ipcRenderer,
-  lifecycle: lifecycleEnum.singleton,
   causesSideEffects: true,
 });
 

src/renderer/bootstrap.tsx

@@ -27,7 +27,7 @@ import { SentryInit } from "../common/sentry";
 import { registerCustomThemes } from "./components/monaco-editor";
 import { getDi } from "./getDi";
 import { DiContextProvider } from "@ogre-tools/injectable-react";
-import type { DependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 import extensionLoaderInjectable from "../extensions/extension-loader/extension-loader.injectable";
 import extensionDiscoveryInjectable from "../extensions/extension-discovery/extension-discovery.injectable";
 import extensionInstallationStateStoreInjectable from "../extensions/extension-installation-state-store/extension-installation-state-store.injectable";
@@ -55,7 +55,7 @@ async function attachChromeDebugger() {
   }
 }
 
-export async function bootstrap(di: DependencyInjectionContainer) {
+export async function bootstrap(di: DiContainer) {
   await di.runSetups();
 
   const rootElem = document.getElementById("app");

src/renderer/cluster-frame-context/cluster-frame-context.injectable.ts

@@ -2,12 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { ClusterFrameContext } from "./cluster-frame-context";
 import namespaceStoreInjectable from "../components/+namespaces/namespace-store/namespace-store.injectable";
 import hostedClusterInjectable from "../../common/cluster-store/hosted-cluster.injectable";
 
 const clusterFrameContextInjectable = getInjectable({
+  id: "cluster-frame-context",
+
   instantiate: (di) => {
     const cluster = di.inject(hostedClusterInjectable);
 
@@ -19,8 +21,6 @@ const clusterFrameContextInjectable = getInjectable({
       },
     );
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default clusterFrameContextInjectable;

src/renderer/components/+catalog/__tests__/custom-columns.test.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import type { ConfigurableDependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 import { computed } from "mobx";
 import type { CatalogCategorySpec } from "../../../../common/catalog";
 import type { LensRendererExtension } from "../../../../extensions/lens-renderer-extension";
@@ -35,7 +35,7 @@ class TestCategory extends CatalogCategory {
 }
 
 describe("Custom Category Columns", () => {
-  let di: ConfigurableDependencyInjectionContainer;
+  let di: DiContainer;
 
   beforeEach(() => {
     di = getDiForUnitTesting();

src/renderer/components/+catalog/__tests__/custom-views.test.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import type { ConfigurableDependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 import { computed } from "mobx";
 import type React from "react";
 import type { LensRendererExtension } from "../../../../extensions/lens-renderer-extension";
@@ -13,7 +13,7 @@ import type { CustomCategoryViewRegistration } from "../custom-views";
 import customCategoryViewsInjectable from "../custom-views.injectable";
 
 describe("Custom Category Views", () => {
-  let di: ConfigurableDependencyInjectionContainer;
+  let di: DiContainer;
 
   beforeEach(() => {
     di = getDiForUnitTesting();

src/renderer/components/+catalog/catalog-entity-store/catalog-entity-store.injectable.ts

@@ -2,16 +2,16 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { CatalogEntityStore } from "./catalog-entity.store";
 import catalogEntityRegistryInjectable from "../../../api/catalog-entity-registry/catalog-entity-registry.injectable";
 
 const catalogEntityStoreInjectable = getInjectable({
+  id: "catalog-entity-store",
+
   instantiate: (di) => new CatalogEntityStore({
     registry: di.inject(catalogEntityRegistryInjectable),
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default catalogEntityStoreInjectable;

src/renderer/components/+catalog/catalog-previous-active-tab-storage/catalog-previous-active-tab-storage.injectable.ts

@@ -2,11 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { browseCatalogTab } from "../../../../common/routes";
 import createStorageInjectable from "../../../utils/create-storage/create-storage.injectable";
 
 const catalogPreviousActiveTabStorageInjectable = getInjectable({
+  id: "catalog-previous-active-tab-storage",
+
   instantiate: (di) => {
     const createStorage = di.inject(createStorageInjectable);
 
@@ -15,8 +17,6 @@ const catalogPreviousActiveTabStorageInjectable = getInjectable({
       browseCatalogTab,
     );
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default catalogPreviousActiveTabStorageInjectable;

src/renderer/components/+catalog/catalog.test.tsx

@@ -14,7 +14,7 @@ import { CatalogEntityRegistry } from "../../api/catalog-entity-registry";
 import { CatalogEntityDetailRegistry } from "../../../extensions/registries";
 import type { CatalogEntityStore } from "./catalog-entity-store/catalog-entity.store";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
-import type { DependencyInjectionContainer } from "@ogre-tools/injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
 import catalogEntityStoreInjectable from "./catalog-entity-store/catalog-entity-store.injectable";
 import catalogEntityRegistryInjectable
   from "../../api/catalog-entity-registry/catalog-entity-registry.injectable";
@@ -95,7 +95,7 @@ describe("<Catalog />", () => {
     }, onRun);
   }
 
-  let di: DependencyInjectionContainer;
+  let di: DiContainer;
   let catalogEntityStore: CatalogEntityStore;
   let catalogEntityRegistry: CatalogEntityRegistry;
   let render: DiRender;

src/renderer/components/+catalog/custom-category-columns.injectable.tsx

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { computed, IComputedValue } from "mobx";
 import type { LensRendererExtension } from "../../../extensions/lens-renderer-extension";
 import rendererExtensionsInjectable from "../../../extensions/renderer-extensions.injectable";
@@ -45,10 +45,11 @@ function getAdditionCategoryColumns({ extensions }: Dependencies): IComputedValu
 }
 
 const categoryColumnsInjectable = getInjectable({
+  id: "category-columns",
+
   instantiate: (di) => getAdditionCategoryColumns({
     extensions: di.inject(rendererExtensionsInjectable),
   }),
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default categoryColumnsInjectable;

src/renderer/components/+catalog/custom-views.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { orderBy } from "lodash";
 import { computed, IComputedValue } from "mobx";
 import type { LensRendererExtension } from "../../../extensions/lens-renderer-extension";
@@ -49,10 +49,11 @@ function getCustomCategoryViews({ extensions }: Dependencies): IComputedValue<Ma
 }
 
 const customCategoryViewsInjectable = getInjectable({
+  id: "custom-category-views",
+
   instantiate: (di) => getCustomCategoryViews({
     extensions: di.inject(rendererExtensionsInjectable),
   }),
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default customCategoryViewsInjectable;

src/renderer/components/+catalog/get-category-columns.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import { orderBy } from "lodash";
 import type { IComputedValue } from "mobx";
 import type { CatalogCategory, CatalogEntity } from "../../../common/catalog";
@@ -85,11 +85,11 @@ const getCategoryColumns = ({ extensionColumns }: Dependencies) => ({ activeCate
 };
 
 const getCategoryColumnsInjectable = getInjectable({
+  id: "get-category-columns",
+
   instantiate: (di) => getCategoryColumns({
     extensionColumns: di.inject(categoryColumnsInjectable),
   }),
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default getCategoryColumnsInjectable;

src/renderer/components/+cluster/cluster-overview-store/cluster-overview-store.injectable.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
 import {
   ClusterOverviewStorageState,
   ClusterOverviewStore,
@@ -13,6 +13,8 @@ import createStorageInjectable from "../../../utils/create-storage/create-storag
 import apiManagerInjectable from "../../kube-object-menu/dependencies/api-manager.injectable";
 
 const clusterOverviewStoreInjectable = getInjectable({
+  id: "cluster-overview-store",
+
   instantiate: (di) => {
     const createStorage = di.inject(createStorageInjectable);
 
@@ -34,8 +36,6 @@ const clusterOverviewStoreInjectable = getInjectable({
 
     return store;
   },
-
-  lifecycle: lifecycleEnum.singleton,
 });
 
 export default clusterOverviewStoreInjectable;