In TypeScript, this code fails to compile — why, and what are the ways to fix it? ```ts type Shape = { kind: 'circle'; r: number } | { kind: 'square'; size: number }; const c = { kind: 'circle', r: 1 }; const s: Shape = c; ```

## What the compiler actually infers When TypeScript infers the type of an object literal with no *contextual type* — no annotation on the variable, no parameter type, no declared return type to guide it — it applies **literal widening** to mutable properties. The literal `'circle'` has the type `"circle"` at the expression level, but because `c.kind` is a mutable property that could later be assigned any string, the inferred property type is widened to `string`: ```ts const c = { kind: 'circle', r: 1 }; // ^? { kind: string; r: number } c.kind = 'square'; // legal — which is exactly why kind is `string` ``` Assigning that to `Shape` then fails: the union requires `kind` to be `"circle"` or `"square"`, and `string` is assignable to neither. The error points at the property: `string` is not assignable to type `"circle"`. ## Why `const` does not save you This is the part candidates get wrong. `const` on a *primitive* binding does prevent widening, because the binding can never be reassigned: ```ts const tag = 'circle'; // type "circle" let tag2 = 'circle'; // type string ``` But `const` on an object only freezes the *binding*, not the properties. The object's fields remain mutable, so their inferred types widen. `const` and `readonly` are different guarantees, and only the second one is about the property. ## Fix 1 — annotate the variable ```ts const c: Shape = { kind: 'circle', r: 1 }; ``` The annotation gives the literal a contextual type. Contextual typing suppresses widening — the compiler checks `'circle'` against the expected literal instead of inferring from scratch — and it also turns on excess-property checking, so a typo in a field name is caught at the literal. The downside is that `c` is now typed as the whole union: `c.r` is an error until you narrow, because the declared type is `Shape`, not the circle member. ## Fix 2 — `as const` ```ts const c = { kind: 'circle', r: 1 } as const; // ^? { readonly kind: "circle"; readonly r: 1 } const s: Shape = c; // fine ``` A const assertion tells the compiler to infer the narrowest type: every literal keeps its literal type and every property becomes `readonly`. The `readonly` modifiers do not block the assignment — property readonly-ness is not part of assignability here — but they do make `c` genuinely immutable in your own code, which is usually what you wanted. If you only need the tag pinned, `{ kind: 'circle' as const, r: 1 }` widens `r` but keeps `kind` narrow. ## Fix 3 — `satisfies` ```ts const c = { kind: 'circle', r: 1 } satisfies Shape; // ^? { kind: "circle"; r: number } c.r.toFixed(2); // allowed — c is still the circle member ``` `satisfies` checks the expression against `Shape` — you get the same error as an annotation if the shape is wrong or the tag is misspelled — but the variable keeps its *inferred*, narrower type rather than being widened to the union. That is the best of both when you want the check and still want to reach into the specific member afterwards. Because it supplies a contextual type, the tag does not widen. ## The same trap, in a helper The most common production form is not a variable at all — it is a factory whose return type is inferred: ```ts function circle(r: number) { return { kind: 'circle', r }; // inferred { kind: string; r: number } } const s: Shape = circle(1); // error ``` Declare the return type (`function circle(r: number): Shape`), or return `{ ... } as const`, or add `satisfies Shape` to the returned literal. Annotating the return type is usually best: it documents the contract and it makes the error appear inside the factory, where the bug is, instead of at every call site. ## Why this is worth knowing A widened tag is a *silent* failure of intent everywhere except the one assignment that catches it. If the value never meets an annotated `Shape`, nothing complains — you just have an object whose `kind` is `string`, and any later `switch` on it narrows nothing. Interviewers use this snippet because it separates candidates who have memorised the syntax of discriminated unions from those who understand that the discriminant only works when the *inferred* type kept the literal. A rule of thumb: whenever a union member is constructed somewhere other than directly at an annotated position, pin the tag — with an annotation, `as const`, or `satisfies`.