You apply `Omit<Shape, "id">` in TypeScript where `Shape` is a union of object types, and the result collapses into a single flat type instead of a union. Why, and how do you keep the variants?

## What you observe Start with a union of object types that share a tag: ```ts type Shape = | { kind: "circle"; r: number; id: string } | { kind: "square"; side: number; id: string }; type Flat = Omit<Shape, "id">; ``` You expect `Flat` to be a union of two trimmed variants. What you actually get is `{ kind: "circle" | "square" }` — one object type, both payload properties gone, and no way to narrow to a variant any more. Hover it in the editor and the surprise is immediate. ## Why it happens Two separate rules combine. **First: `keyof` over a union is an intersection of key sets.** A value of type `A | B` is guaranteed to have only the properties that *both* `A` and `B` have — you cannot safely read `r` from a value that might be the square. So `keyof (A | B)` is `keyof A & keyof B`. Here that is `"kind" | "id"`. `r` and `side` are simply not in it. **Second: `Omit` consumes `keyof T` directly.** Its definition is `Pick<T, Exclude<keyof T, K>>`. It computes the union's shared keys, subtracts `"id"`, and picks `"kind"` out of the union. `Pick` over a union of `T` gives each property the union of its types across members, so `kind` becomes `"circle" | "square"` and the result is a single object type. Nothing here is a special case for unions — it is the definition executing literally. The mental model to carry away is that `Omit` treats its input as one type, and any type-level operation that goes through `keyof T` will flatten a union the same way. ## Why it matters more than it looks The collapsed type is not merely narrower; it is *wrong in a way the checker cannot help with*. The whole value of a discriminated union is that checking the tag tells the compiler which payload is present. After the collapse, `kind` is still a literal union but there is no payload attached to either branch, so a `switch` on `kind` narrows to nothing useful and exhaustiveness checks lose their meaning. Code that used to be safe now needs assertions to compile, and assertions are exactly where unsound code enters. This bites most often in component props and in "same shape minus the server-assigned fields" input types, where the source really is a union of variants and the trim is meant to apply to each. ## The fix Apply `Omit` to one member at a time. A conditional type whose checked type is a bare type parameter is *distributive*: the compiler evaluates it separately for each member of a union and unions the results. ```ts type DistributiveOmit<T, K extends keyof any> = T extends unknown ? Omit<T, K> : never; type Kept = DistributiveOmit<Shape, "id">; // { kind: "circle"; r: number } | { kind: "square"; side: number } ``` `T extends unknown` is a condition every type satisfies — its only job is to put `T` in the distributive position. Inside the true branch, `T` is one member, so `keyof T` is that member's full key set and the trim behaves as you wanted. The same wrapper shape works for `Pick`. The cost is a helper in your codebase that readers must recognise, and a name that does not appear in the standard library. Many teams define both `DistributiveOmit` and `DistributivePick` once in a `types` module and treat the plain versions as the exception. ## Alternatives worth knowing Sometimes the better answer is not to trim a union at all. If the union members already differ, defining each trimmed variant explicitly and unioning them is more readable than any helper, and the explicit version documents intent. If the field you are removing is on every member and nothing else varies structurally, consider whether the union should have been one type with a discriminated payload property instead — a modelling fix rather than a type-level one. And if what you actually want is *the union member that has a given tag*, that is a filtering operation over the union rather than a property trim; reaching for `Omit` there is a sign the model and the operation are mismatched. ## How to answer this under interview pressure Say the two rules, in order: `keyof` over a union gives shared keys only, and `Omit` is defined through `keyof T`. Then show the distributive wrapper and name why the bare type parameter is what makes it work. If you can also say what breaks downstream — narrowing and exhaustiveness — you have shown you have hit this in production rather than read about it.