Rely on a mapping to value each variant of a discriminated union

When consuming all variants of a discriminated union with some if statements, TypeScript narrows down the type to the specifics of the variant. I understand that to do the same while expressing the logic with a mapping from the discriminant to a function to process this variant, the mapping should be seen as distributive type, and not just a mapped type. I read https://stackoverflow.com/a/73262902/2924547 and https://github.com/microsoft/TypeScript/pull/47109, but still, I do not manage to apply this to my use case.

type Message =
  | { kind: "mood"; isHappy: boolean }
  | { kind: "age"; value: number };

// Could be derived from `Message` with
// type ExtractMessage<M, P> = M extends { kind: P } ? Omit<M, "kind"> : never;
//
// type Mapping = {
//   [key in Message["kind"]]: (
//     payload: Omit<ExtractMessage<Message, key>, "kind">
//   ) => void;
// };
type Mapping = {
  mood: (payload: { isHappy: boolean }) => void;
  age: (payload: { value: number }) => void;
};

// OK: TypeScript complains if a key is missing or the signature is wrong 
const mapping: Mapping = {
  mood: ({ isHappy }) => {
    console.log(isHappy);
  },
  age: ({ value }) => {
    console.log(value + 1);
  },
};

const process = (message: Message) => {
  // NOT OK: TypeScript complains because it does not now we are dealing with the right message
  mapping[message.kind](message);
};

The refactoring described in microsoft/TypeScript#47109 wants you to write everything in terms of a fairly simple "basic" object type like

interface Mapping {
  mood: {
    isHappy: boolean;
  };
  age: {
    value: number;
  };
}

which, in your case, could be generated from your original Message type, which I'll rename out of the way:

type _Message =
  | { kind: "mood"; isHappy: boolean }
  | { kind: "age"; value: number };

type Mapping = { [T in _Message as T["kind"]]: 
  { [K in keyof T as Exclude<K, "kind">]: T[K] } 
}

Other types should either be mapped types on that object type, such as

type MappingCallbacks =
  { [K in keyof Mapping]: (payload: Mapping[K]) => void }

const mappingCallbacks: MappingCallbacks = {
  mood: ({ isHappy }) => {
    console.log(isHappy);
  },
  age: ({ value }) => {
    console.log(value + 1);
  },
};

or as distributive object types which are mapped types into which one has immediately indexed with all the keys to get a union, such as:

type Message<K extends keyof Mapping = keyof Mapping> =
  { [P in K]: { kind: P } & Mapping[P] }[K]

type M = Message
/* type M = 
     ({ kind: "mood"; } & { isHappy: boolean; }) | 
     ({ kind: "age"; } & { value: number; }) 
*/

Then your operations must be generic in the key type of your basic interface:

const process = <K extends keyof Mapping>(message: Message<K>) => {
  mappingCallbacks[message.kind](message);
};

Even though conceptually the non-generic version of process should work, where message is just a union, the compiler just can't follow that logic that the different members of the union each obey an analogous constraint. Indeed, it was the failure to do this with pure unions that was the subject of microsoft/TypeScript#30581, the problem which microsoft/TypeScript#47109 was written to solve.

Playground link to code