How to infer types of deeply nested properties?

I'm trying to write a function that takes in a descriptor object and uses the inferred type information to return a different object that has a nice API with strong typing.

The problem I'm running into is that TypeScript seems to only infer the types of nested properties if they are constrained to something like a union type. If they are constrained to a primitive type (e.g. string), they stay typed as that primitive and don't narrow to the actual literal that is passed in.

type ChildType = 'foo' | 'bar' | 'baz';

type ChildDescriptor<
    TName extends string = string,
    TType extends ChildType = ChildType,
> = {
    name: TName;
    type: TType;
};

type ParentDescriptor<
    TSomeProp extends string,
    TChildren extends ChildDescriptor[],
> = {
    someProp: TSomeProp;
    children: [...TChildren];
};

// Identity function so we can observe what types are inferred
const identity = <
    TSomeProp extends string,
    TChildren extends ChildDescriptor[],
>(
    descriptor: ParentDescriptor<TSomeProp, TChildren>,
) => descriptor;

const inferredValue = identity({
    someProp: 'I get inferred',
    children: [
        {
            name: 'I don\'t get inferred',
            type: 'foo',
        },
        {
            name: 'I don\'t get inferred either',
            type: 'baz',
        }
    ],
});

const [childA, childB] = inferredValue.children;

Playground

In the example above, the children property of inferredValue is properly inferred as a tuple, and the someProp property as well as the type property of the children objects are narrowed to the specific literal types as I want. However, the name property of the child objects is staying typed as string and I'm not sure why.

I can work around this by adding as const after each value that's not narrowing, or even add it after each child object. It doesn't work any nest level lower than that because of the tuple, it becomes read-only and then it's hard to work with in an API with generics. In any case, I'd like to avoid this solution at all since adding a type assertion feels like a hack and not a real solution.

In the end, these descriptor objects will be generated with another piece of software I will build, so I will go with the workaround if I have to. I just wanted to see if there are other solutions that I'm not seeing.

The environment I'm working in is constrained to TypeScript 4.7.4, so I have to stick with features available in that version.

Here's how you can do it, if you don't want to use as const and make the array readonly -

type Cast<A, B> = A extends B ? A : B;
type Narrowable = string | number | bigint | boolean;
type Narrow<A> = Cast<
A,
[] | (A extends Narrowable ? A : never) | { [K in keyof A]: Narrow<A[K]> }
>;
type ChildType = 'foo' | 'bar' | 'baz';
type ChildDescriptor<
TName extends string = string,
TType extends ChildType = ChildType,
> = {
name: TName;
type: TType;
};
type ParentDescriptor<
TSomeProp extends string,
TChildren extends ChildDescriptor[],
> = {
someProp: TSomeProp;
children: [...TChildren];
};
// Identity function so we can observe what types are inferred
const identity = <
TSomeProp extends string,
TChildren extends ChildDescriptor[],
>(
descriptor: ParentDescriptor<TSomeProp, Narrow<TChildren>>,
) => descriptor;
const inferredValue = identity({
//    ^? const inferredValue: ParentDescriptor<"I get inferred", [{ name: "I don't get inferred"; type: "foo"; }, { name: "I don...
someProp: 'I get inferred',
children: [
{
name: "I don't get inferred",
type: 'foo',
},
{
name: "I don't get inferred either",
type: 'baz',
},
],
});
const [
childA,
//^? const childA: { name: "I don't get inferred"; type: "foo"; }
childB,
//^? const childB: { name: "I don't get inferred either"; type: "baz"; }
] = inferredValue.children;

Here's a Playground link.

<h2>Explanation</h2>

The reason this works is because of the Typescript compiler scans the input, with it's algorithm, it first of all, scans the generics that are non-contextual and then the ones that are contextual, you can read more about it here and here.

So, if we use the Narrow utility, Typescript is forced to run the analysis for capturing the type on it, and since an Array is really an object, we map over all it's properties, exhaustively, as you can see that this is a recursive utility. This example would give you more insight into it -

type A = { [K in keyof ["some", "things"]]: ["some", "things"][K] }
//   ^? type A= { [x: number]: "some" | "things"; 0: “some"; 1: "things"; length: 2; toString: () => string; toLocaleString: (...

The intermediate Cast utility is where all the magic happens, it's really a trick that makes the compiler infer the type of A, through type B, essentially, if you add two generics and constraint one of them and then use it in another constrained generic, the compiler infers the type like as const, for example -

type Some = number | string;
function getValues<N extends Some, K extends Record<keyof K, N>>(arg: K) {
return arg;
}
const value = getValues({ a: "something", b: "another thing" });
//    ^? const value: { a: "something"; b: “another thing”; }