What's the difference between `type` and `interface`? When do you reach for each?
Whether you have a principled default, not just 'they're basically the same'.
Both describe object shapes. Interfaces are open (declaration merging — multiple declarations combine) and are the idiom for public object/class contracts. Type aliases are closed but far more expressive: unions, intersections, tuples, mapped and conditional types, and aliasing primitives/functions. Practical rule: interface for object shapes and things classes implement; type when you need a union, tuple, or any computed type. Consistency inside a codebase matters more than the choice. More precisely: `interface extends` produces slightly better error messages and is cached by the compiler (it can be marginally faster in huge codebases), while `type` uses `&` intersection to combine. Declaration merging is a double-edged feature — great for augmenting third-party module types (declare module), dangerous inside app code because two files can silently reshape the same interface. A `type` alias can't be reopened, which some teams prefer for exactly that reason. Both support generics; only `type` can alias a primitive, a union, or a mapped/conditional type.
interface for a component's props contract a library might extend; type for `type Status = 'idle' | 'loading' | 'error'`.