How to narrow down error in a custom type?

[ayZagen]

Hello, I couldn't find if this is asked or there is an example, if so, sorry for that.

Here is an implementation of OneOf, it is not bullet-proof but it helps with my question.

export interface TUnionOneOf<T extends TSchema[]> extends TSchema {
    [Kind]: 'UnionOneOf'
    static: { [K in keyof T]: Static<T[K]> }[number]
    oneOf: T
}

export function UnionOneOf<T extends TSchema[]>(oneOf: [...T], options: SchemaOptions = {}) {
    const discriminatedSchemas = oneOf.reduce( (acc, schema) => {
        const properties = schema.properties 
        if(properties[options.discriminator]){
            if(!properties[options.discriminator].const){
                throw new Error('discriminator must be a const')
            }
            acc[properties[options.discriminator].const] = schema
        } else {
            throw new Error(`All schemas must include discriminator property: ${options.discriminator}`)
        }
        return acc
    }, {})
    function UnionOneOfCheck(schema: TUnionOneOf<TSchema[]>, value: unknown) {
        if(value[options.discriminator]){
            return Value.Check(discriminatedSchemas[value[options.discriminator]], value)
        }
        return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
    }
    if (!TypeRegistry.Has('UnionOneOf')) TypeRegistry.Set('UnionOneOf', UnionOneOfCheck)
    return { ...options, [Kind]: 'UnionOneOf', oneOf } as TUnionOneOf<T>
}

const A = Type.Object({
    type: Type.Literal('A'), // Discriminator
    value: Type.Number()
})
const B = Type.Object({
    type: Type.Literal('B'), // Discriminator
    value: Type.String()
})
const C = Type.Object({
    type: Type.Literal('C'), // Discriminator
    value: Type.Boolean()
})

const U = UnionOneOf([A, B, C], { discriminator: 'type' })


const R = [...Value.Errors(U, { type: 'C', value: '42' })]

console.log(R)

Everyhting works so far, but instead of showing Expected kind 'UnionOneOf' error message, I would like to show the narrowed error.

In this block I already narrow down the schema, but the error is not.

if(value[options.discriminator]){
  return Value.Check(discriminatedSchemas[value[options.discriminator]], value)
}

Is there any way to narrow down the error too ?

The first thing that comes to my mind, a new registry could be provided like TypeRegistry but for errors.
In errors/errors.ts#FromKind function the checker is resolved from the registry so the error creation function could also be provided. Even better TypeRegistry.Set function could accept an additional argument for this.