Infer Generics Types, from Record<string<...> Aggregation for return type constraints

If you can imagine capturing type information at the same time as runtime information, were the inferred types literals match that those of the runtime types, so that one can implicitly at the same time
capture the typescript types and runtime information for the shape of the typescript type, in one shot.
This I have been doing quite successfully, and is quite powerfully. I find myself using what I term type constraints, to capture information at runtime in specific categories, that typings constraints impose. Which allows me to do advance record mixing.
This allows one to impose constraints on free form runtime information, to ensure
runtime information is correctly categorized for typing system performance of mixing.

Example of return type constraints for categorization for mixing

interface IConstraints<Param1 extends 'Param1A' | 'Param1B',
Param2 extends 'Param2A' | 'Param2B',
Param3 extends 'Param3A' | 'Param3B'> = {
__Param1 : Param1
__Param2 : Param2
__Param3 : Param3
}
// Typically Record< IConstraints.. Is a recursive record capture pattern, with neasted records
class RecordMix<
Dim1 extends Record<string, IConstraints<'Param1A',any,any>>,
Dim2 extends Record<string, IConstraints<'Param1A',any,any>,
Dim3 extends Record<string, IConstraints<never, 'Param2B','Param3A'>
Dim4 extends Record<string, IConstraints<never,'Param2A','Param3B'>
{
 // Use the constructor to capture the runtime sets of information.
}

Functionality as of current.

interface Builder<A extends string, B extends string>
{
    __A : A,
    __B : B
}

type AString = 'A' | 'E' | 'G';
type BString = 'B' | 'F' | 'H';

type RecordBuilder<A extends AString, B extends BString> = Record<string, Builder<A,B>>

const builderRecord = {
    a : {} as any as Builder<'A','B'>,
    e : {} as any as Builder<'E','F'>,
   // g : {} as any as Builder<'G','F'>,
}

const builderRecordInvalid = {
    a : {} as any as Builder<'A','B'>,
    e : {} as any as Builder<'E','F'>,
   g : {} as any as Builder<'G','F'>,
}

function Capture<A extends 'A' |'E', B extends BString, Rec extends RecordBuilder<A, B>>(record : Rec)
{
    return {} as any as {Ra:A,Rb:B};
}

const result = {a:Capture(builderRecord)} //OK
const result = {a:Capture(builderRecordInvalid)} //Failed input type constraints not met

// Type
const result: {
    a: {
        Ra: "A" | "E";
        Rb: BString;
    };
}

Functionality Feature Request, using infer of aggregate

function Capture<A extends 'A' |'E', B extends BString, Rec extends RecordBuilder<infer A, infer B>>(record : Rec)
{
    return {} as any as {Ra:A,Rb:B};
}

const result = {a:Capture(builderRecord)} //OK
const result = {a:Capture(builderRecordInvalid)} //Failed input type constraints not met

// Type Results
const result: {
    a: {
        Ra: "A" | "E";
        Rb: "B" | "F";
    };
}

Functionality Feature Request current mechanisms

type ExtractRecordComponent<Shape extends Record<string,any>, T extends Record<string, Shape>, Key extends string> = ({
    [K in keyof T] : T[K][Key]
})[keyof T]

function Capture<A extends 'A' |'E', B extends BString, Rec extends RecordBuilder<A, B>>(record : Rec)
 : {Ra:ExtractRecordComponent<Builder<any,any>,Rec,'__A'>, Rb:ExtractRecordComponent<Builder<any,any>,Rec,'__B'>}
{
    return {} as any;
}

const result = {a:Capture(builderRecord)} //OK
const result = {a:Capture(builderRecordInvalid)} //Failed input type constraints not met

// Type Results
const result: {
    a: {
        Ra: "A" | "E";
        Rb: "B" | "F";
    };
}

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

The issue names no source files, tests, or entry points. Start by reducing the RecordBuilder and Capture examples to a minimal inference case, then compare the requested aggregate infer behavior with the current ExtractRecordComponent workaround; done would require precise inference rules and tests for the stated accepted and rejected inputs.