Type Space vs Value Space

The plain-language idea

Every identifier in a TypeScript file exists in one (or both) of two separate namespaces:

• Value space — real things that exist when the code runs: variables, functions, actual objects.
• Type space — compile-time-only descriptions, erased before the code ever runs: interfaces, type aliases, generic parameters.

class User { name: string = ""; }

const a: User = new User();   // "User" on the right = value space (the constructor, calling it)
                                // "User" on the left = type space (the type of `a`)

function f(x: typeof a) {}     // typeof crosses FROM value space INTO type space

The same identifier, User, means genuinely different things depending on position — this is only possible because a class declaration creates an entry in both namespaces at once (a real constructor function, and a type describing its instances). An interface only ever creates a type-space entry; a const only ever creates a value-space entry.

Every identifier lives in type-space (compile-time, erased before runtime), value-space (real at runtime), or both.

BackNext

What people usually miss

Watch out

• "Cannot find name 'X'. Did you mean the instance type 'X'?"-style errors are almost always a type-space/value-space mixup — using an interface where a real runtime value is expected, or vice versa.
• Enums (from the enums lesson) are unusual because they occupy both spaces, exactly like classes — Status.Active is a real runtime value, and Status is also usable as a type, which is exactly why enums generate actual JavaScript while interfaces don't.
• This is the deeper reason branded types work at all — the __brand field lives purely in type-space, contributing nothing to value-space, so it can shape how the type checker reasons about a value without adding a single byte to what actually exists at runtime.

Why this matters in interviews

Explicitly naming "type space vs value space" as the underlying reason for a specific confusing error is a genuinely senior-level move — it reframes a pile of individually-memorized gotchas (enums are weird, typeof is overloaded, branding works) as one consistent mental model.