Combination of 20 provideValue()/provideFactory() calls make vscode unusable about typed-inject HOT 6 OPEN

interface Foo {
  foo: string;
}
class Bar {
  static readonly inject = ['foo'] as const;
  constructor(foo: Foo){ }
}
rootInjector.provide({
   foo: { value: { foo: 'hello'} },
   bar: { clazz: Bar }
})

type AsContainerWithInstanceTypes<TIn extends Record<string, ((...args: any) => any) | { value: any }>> = {
  [prop in keyof TIn as prop]: TIn[prop] extends { value: any }
    ? TIn[prop]["value"]
    : TIn[prop] extends (...args: any) => any
    ? ReturnType<TIn[prop]>
    : unknown;
};

export function createDiContainer<
  T extends Record<
    string,
    | (((...args: AsContainerWithInstanceTypes<T>[keyof AsContainerWithInstanceTypes<T>][]) => any) & {
        inject?: readonly (keyof T)[];
      })
    | { value: any }
  >,
>(
  dependencies: T,
  options?: { logger?: Logger; onResolve?: (prop: string, val: any) => void },
): AsContainerWithInstanceTypes<T> {
  const _containerCache: Map<string, any> = new Map();
  const _onResolve = (prop: string, val: any) => {
    if (options?.onResolve) {
      options?.onResolve(prop, val);
    }
    _containerCache.set(prop, val);
    options?.logger?.debug(`returning ${prop} for first time`);
    return val;
  };

  const handler = {
    get: function (target: any, prop: string, receiver: any) {
      options?.logger?.debug(`resolving ${prop}`);
      if (_containerCache.has(prop)) {
        options?.logger?.debug(`returning ${prop} from cache`);
        return _containerCache.get(prop);
      }

      const targetDep = dependencies[prop];
      if (!targetDep) {
        throw new Error(`dependency "${prop}" not registered with container!`);
      }

      // TODO: implement classes. -mc
      if (!_.isFunction(targetDep)) {
        const resolved = targetDep.value;
        return _onResolve(prop, resolved);
      }

      const paramNames = (targetDep as any).inject || [];
      options?.logger?.debug(
        `${prop} has ${paramNames.length === 0 ? "no dependencies" : `dependencies: ${paramNames.join(", ")}`}`,
      );
      const params = paramNames.map((dep: string) => this.get(target, dep, receiver));
      const resolved = targetDep(...params);
      return _onResolve(prop, resolved);
    },
  };

  return new Proxy(dependencies, handler);
}

// argument  (to prevent from providing value with same token)
token: Token
// ↓
token: Token extends keyof TContext ? never : Token

// return type
Injector<TChildContext<TContext, R, Token>>
// ↓
Injector<{ [K in keyof TContext]: TContext[K]} & { [T in Token]: R }>;