Soundness

- types are great, and powerful type systems are very useful.

- we just need to make it strict and sound, remove some footguns, and stabilize the ambiguities.
- and ofc need to be stable and deterministic, incrementally compilable, strict boundaries, make it fast

- So, how much of TS can we make sound, predictable, and fast?
- quite a lot, actually
- and it turns out that TS algebra and generics are much faster than macros since it's essentially a very constrained macro system already

- the easy part first to first: kill all the no soundness holes!
- no dynamic shenanigans, no JS legacy compat
- need strict, sound TS with predictable module boundaries and type behavior (roughly equivalent to tsc's isolatedDeclarations)
- "A module's public declarations can be recovered from that module alone."
- (isolated declarations must be directly transcribable)
- changing and constraining the type system just a bit gives us a lot more parallelism
- ideally also make it fast to compile, which requires cleaner boundaries than standard TS gives

All of the inherited JavaScript legacy-era dynamisms must go:
- no dynamic JS shenanigans or monkey patching, so goodbye to __proto__ or anything like that
- no module.x = foo.., no mutable globals
- no Object.prototype, Object.isOwnProperty, Object.assign, ...
- no Reflect.*
- no Proxy
- no delete obj.x
- no __proto__
- no eval / Function
- no with
- no "truthiness"; conditionals always take booleans
- no array holes
- oh also: no sequence expressions, who needs sequence expressions

There are also some TypeScript features that are not sound or just not needed in a purely strict model:
- no declaration merging / no separate type and value spaces (as such)
- no any, no as except for widening casts
- no predicate functions (e.g. isUser(user: any): asserts user is User is unsound)
- unknown still works as a fat existential
- no symbol / string keyed duck typing (proper traits)
- no thenables (nominal Promise, TAsk only)