Open-source Ruby gem by Joel Drapper. Treats any object responding to `===` as a type and provides a library of composable type constructors: _Array, _Hash, _Tuple, _Set, _Union, _Intersection, _Constraint, _Interface (duck typing), _Deferred (recursive types like _JSONData), _Nilable (intentionally ugly so nilable types stand out). Also ships LiteralStruct/LiteralData (mutable/immutable typed value objects built with `prop name, Type`), Literal::Properties (mixable prop macro), Literal::Enum (constant enumerations inheriting from a value type, with value/predicate/coerce/`&status` support and always-frozen instances), and Literal::Value/Decorator (single-value wrappers like UserID with selective method delegation). Uses code generation so initializers are equivalent to hand-written ones; types do essentially zero runtime allocations (inline-cache may allocate once); primitive unions compile to set-based O(1) membership; nested unions auto-flatten; types are allocated at boot and copy-on-write-shared across processes via eager loading. Supports keyword/positional/splat/block prop arguments, readers/writers with public/private/protected/false, coercion blocks, default values (must be frozen or wrapped in a Proc to avoid shared-mutable-default bugs). Roadmap: typed collection objects (array partially done, then tuple/hash/set) that can't be corrupted after initialization, type-to-type subtype comparison for variance shortcuts (concat-basket-of-apples-into-basket-of-fruit in O(1)), cross-property validation via named-parameter blocks, a result monad integrated with the type system, and LLM-schema generation/validation. Deployed at Clear Scope where it reduced production error rates. Design philosophy: Goldilocks between full static typing and pure dynamism; incremental 'accordion of complexity'; types as first-class Ruby objects; errors are careful (tells you which item in an array failed and what was expected).