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

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.

Start with the linked TypeScript Playground example and compare inference for something and somethingBugged, especially when the inferred type is wrapped in a tuple or object. Investigate why M widens from "foo" to "foo" | "bar" only in the wrapped return type. Done means the wrapped form preserves the exact "foo" type without requiring as const.