Incorrect widening (constraint fallback?) during inference when union with `undefined` appears in constraint

[Mesteery]

Bug Report

🔎 Search Terms

union, type inference, imprecise union generic type, generic type.

🕗 Version & Regression Information

This is reproducible on all versions of the playground.

⏯ Playground Link

Playground link with relevant code

💻 Code

export interface Something<
  R extends
    | {
        [K in 'foo' | 'bar' | 'baz']?: {
          r?: unknown;
          p?: unknown;
        };
      }
    | undefined = undefined
> {}

const o: Something<{ foo: { r: 1; p: 2 }; bar: { r: 3 } }> = {};

declare function something<M extends T extends Something<infer R> ? keyof R : never, T extends Something>(
  key: M,
  something: T
): M;

declare function somethingBugged<M extends T extends Something<infer R> ? keyof R : never, T extends Something>(
  key: M,
  something: T
): [M];

const normal = something('foo', o);
// got: "foo"
// expected: "foo"

const bugged = somethingBugged('foo', o);
// got: ["foo" | "bar"]
// expected: ["foo"]

// However with `as const`, the correct type is returned.
const ugly = somethingBugged('foo' as const, o);
// got: ["foo"]
// expected: ["foo"]

🙁 Actual behavior

The type loses its precision and is the union instead of the exact type.

🙂 Expected behavior

The type is exact.

---

What is strange is that the generic type M loses precision ("foo" -> "foo" | "bar") with the somethingBugged function which returns a tuple of M (and it does the same thing with any other "wrapper", such as an object).
Whereas with the something function there is no problem. Both functions are identical.

[RyanCavanaugh]

Reduced and removed possible red herrings

type SomethingConstraint = undefined | Record<"foo" | "bar", number>;
//                         ^^^^^^^^^ matters, somehow?
interface Something<R extends SomethingConstraint> {
  _: R;
// ^ not needed but provided to show this isn't related to structural inference
}

type KeyOfR<T> = T extends Something<infer R> ? keyof R : never;
declare function something1<T extends Something<SomethingConstraint>, M extends KeyOfR<T>>(t: T, m: M): M;
declare function something2<T extends Something<SomethingConstraint>, M extends KeyOfR<T>>(t: T, m: M): [M];

declare const o: Something<{ foo: 1; bar: 1 }>;
const foo1 = something1(o, 'foo');
// got: "foo"
// expected: "foo"

const foo2 = something2(o, 'foo');
// got: ["foo" | "bar"]
// expected: ["foo"]

[RyanCavanaugh]

@a-tarasyuk want a challenge? 😜