How to correctly infer the type of a key with direct key access and generic interface in TypeScript?

I am trying to get TypeScript to correctly infer the types that are valid in the following context:

I have 2 interfaces

interface A {
  first: string;
}

type B = {
  second: string;
}

as well as a generic interface that has 2 mappers where the types depend on each other, something like

interface Gen<T extends string> {
  firstMapper: () => T;
  callback(arg: T): string;
}

I want also to have an interface that records multiple Gen interfaces

interface Aobject {
  "a": Gen<"a">,
  "b": Gen<"b">,
}

Finally, I want to create function that takes a key of AObject, retrieves the configuration from the AObject interface calls the firstMapper and then the callback such as:

const buildMapping = (configKey: keyof Aobject, arg: Aobject) => {
  const myA: Aobject = {
    "a": {
      firstMapper: () => "a",
      callback: (input) => ("result" + input)
    },
    "b": {
      firstMapper: () => "b",
      callback: (input) => ("result" + input)
    }
  }

  const selected = myA[configKey];
  selected.callback(selected.firstMapper());
}

However, when I try to do this, I have an error

Argument of type 'string' is not assignable to parameter of type 'never'.
  Type 'string' is not assignable to type 'never'.

However, if I change to this

  if (configKey === "a") {
    const selected = myA[configKey]
  selected.callback(selected.firstMapper())
  }
  if (configKey === "b") {
    const selected = myA[configKey]
    selected.callback(selected.firstMapper())
  }

there is no error.

My understanding is that Typescript does not understand that if the configKey is of type "b", then selected can only have the type

b {
   firstMapper: () => "b",
   callback: (input) => ("result" + input)
}

instead TS "thinks" that the callback can be called with both and tries to create the intersection of type "a" and type "b" which results in never.

I am wondering if there is a better way to handle this use case, because I find it weird having to write an if case executing the same piece of code.

I tried to create a more generic interface because I thought the problem might come from the AObject definition but no success.

I created a small playground to reproduce the issue.

Here are two ways to satisfy the compiler:

1. You can use a type assertion:

   TS Playground

   type Gen<T extends string> = {
     firstMapper: () => T;
     callback(arg: T): string;
   };
   
   type Aobject = {
     a: Gen<"a">;
     b: Gen<"b">;
   };
   
   function buildMapping<K extends keyof Aobject>(
     configKey: K,
     arg: Aobject,
   ) {
     const selected = arg[configKey] as Gen<K>;
     //                              ^^^^^^^^^
     selected.callback(selected.firstMapper());
   }
   
   

2. You can define the type Aobject as a mapped type and the compiler will infer correctly without the assertion. The resulting type is the same:

   TS Playground

   type Gen<T extends string> = {
     firstMapper: () => T;
     callback(arg: T): string;
   };
   
   type Aobject = { [Str in "a" | "b"]: Gen<Str> };
     //^? type Aobject = { a: Gen<"a">; b: Gen<"b">; }
   
   function buildMapping<K extends keyof Aobject>(
     configKey: K,
     arg: Aobject,
   ) {
     const selected = arg[configKey];
     selected.callback(selected.firstMapper());
   }