Why Type 'Pick<T, K> & Omit<T, K>' is not assignable to type 'T'?

I found a puzzling error, let's say I want to have a rather useless function which merges two complementing partials of an object:

function foo<T extends object, K extends keyof T>(a: Pick<T, K>, b: Omit<T, K>): T {
    return { ...a, ...b } // TS2322: Type 'Pick<T, K> & Omit<T, K>' is not assignable to type 'T'. 'Pick<T, K> & Omit<T, K>' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'object'.
}

I got the error above, while the code below obviously works:

interface Test {
    a: string,
    b: string
}

const a: Pick<Test, 'a'> = { a: 'a' }
const b: Omit<Test, 'a'> = { b: 'b' }

const t: Test = { ...a, ...b }

The error is trying to tell me that I can come up with a T and K where Pick<T, K> & Omit<T, K> is not T. Can somebody give me such an example (or any other explanation for the error above)?

Edit 1:

What's even stranger is that TS itself considers T extends Pick<T, K> & Omit<T, K> true:

function foo<T extends object, K extends keyof T>(a: Pick<T, K>, b: Omit<T, K>): T extends Pick<T, K> & Omit<T, K> ? T : any {
    const res: Pick<T, K> & Omit<T, K> = { ...a, ...b }
    return res // TS2322: Type 'Pick<T, K> & Omit<T, K>' is not assignable to type 'T extends Pick<T, K> & Omit<T, K> ? T : any'.
}

Edit 2:

Apparently Pick<T, K> & Omit<T, K> is a subset of T, so there must be a case possible where something exists in T which does not exists in Pick<T, K> & Omit<T, K>:

function foo<T, K extends keyof T>(x: Pick<T, K> & Omit<T, K>): T {
    return x // TS2322: Type 'Pick<T, K> & Omit<T, K>' is not assignable to type 'T'. 'T' could be instantiated with an arbitrary type which could be unrelated to 'Pick<T, K> & Omit<T, K>'.
}

function bar<T, K extends keyof T>(x: T): Pick<T, K> & Omit<T, K> {
    return x // no issue
}

There is indeed a possibility for unsoundness here. Both Pick and Omit are implemented as mapped types and their result may not contain all the characteristic of the source type.

Consider this:

interface Test {
    (arg: string): string
    a: string,
    b: string
}

const a: Pick<Test, 'a'> = { a: 'a' }
const b: Omit<Test, 'a'> = { b: 'b' }

const t: Test = { ...a, ...b }
//    ~ Type '{ b: string; a: string; }' provides no match 
//      for the signature '(arg: string): string'

I have given Test a call signature. Both Pick<Test, 'a'> and Omit<Test, 'a'> do not result in a type with a call signature, leading to a situation where Pick<Test, 'a'> & Omit<Test, 'a'> is not assignable to Test.

There is also another problem: The compiler is lacking the ability to properly analyze the result of operations like Pick<T, K> when T and K are generic types. The types T and K act more like placeholders. Their concrete type is not known until the function is called, so the compiler only has a limited understanding what intersecting Pick<T, K> with Omit<T, K> would mean. You can see a discussion about a similar problem here at #28884.

Playground