Unsound calls allowed on a function coming from a deferred indexed access when intersection is involved

Bug Report

🔎 Search Terms

deferred index access unsound call union intersection

🕗 Version & Regression Information

• This is the behavior in every version I tried

⏯ Playground Link

Playground link with relevant code

💻 Code

type A = {
  type: "A";
  value: string;
};

type B = {
  type: "B";
  value: number;
};

type Message = A | B;

export function handle<M extends Message>(callbacks: {
  [K in M["type"]]: (msg: (M & { type: K })["value"]) => unknown;
}) {
  window.addEventListener("message", (event) => {
    const msg = event.data as M;
    // should be an error because it's too permissive
    callbacks[msg.type as keyof typeof callbacks](msg.value);

    // one or the other must be wrong here
    callbacks[msg.type as keyof typeof callbacks]("");
    callbacks[msg.type as keyof typeof callbacks](100);
  });
}

🙁 Actual behavior

There is no error even though it should be based on Ander's comment here. Note that the comment is about a different variant of this signature, one using Extract. Both the Extract and intersection variants are essentially the same though - one errors today and one doesn't.

🙂 Expected behavior

I would expect to get an error here, just like in the Extract-based variant (TS playground)

Start with the linked TypeScript Playground reproductions and compare the intersection-based signature with the Extract-based variant. Determine why the two calls accepting "" and 100 receive no error in one version, then add a regression test and ensure the unsound calls are rejected.