Type system

A JS-faithful IEEE-754 double: 0.1 + 0.2 is 0.30000000000000004, 10 / 3 is 3.3333333333333335, 1 / 0 is Infinity. The explicit JSDoc integer types are the opt-in escape hatch when real integer semantics matter.

console.log(0.1 + 0.2)   // 0.30000000000000004
console.log(10 / 3)      // 3.3333333333333335
console.log(2 ** -1)     // 0.5

The string type, lowered to a pointer at the IR level.

The boolean type, lowered to a single-bit i1.

The absence of a return value on a function.

The null and undefined values, represented as a sentinel null pointer.

A JSDoc @type override that gives a binding real fixed-width integer semantics: int8..int64 and uint8..uint64, with integer division, exact values past 2^53, and bit-width storage.

A JSDoc @type override selecting float32 or float64. Float-to-string is JS-faithful: the shortest decimal that round-trips, per ECMAScript Number::toString, so 1.1 + 2.2 prints 3.3000000000000003 and integer-valued floats drop the point. A float32 prints against its widened double.

A runtime-tagged value supporting declare/assign/reassign/print/typeof/=== plus bare any params and returns on every function shape. Objects and arrays box by reference — === is reference identity, typeof is "object".

let x: any = 5
x = "hello"
x = true
console.log(typeof x)   // boolean

The type-safe counterpart to any, with the same Staged V1 scope: declare/assign/reassign/print/typeof/=== plus bare params and returns.

The bottom type. A (): never function that always throws works correctly.

Opaque unique values — Symbol()/Symbol("desc") (no new, Symbol is not a constructor), ===/!==, typeof, .description, .toString(), and the Symbol.for/Symbol.keyFor registry (keyFor gives undefined for a symbol not in it). Uniqueness comes from the value's own heap-pointer identity, so two Symbol() calls with the same description are never equal.

const a = Symbol("id")
const b = Symbol("id")
console.log(a === b)                  // false
console.log(Symbol.keyFor(Symbol.for("app")))  // app

Arbitrary-precision integers over a backend-agnostic ABI, selectable via -bigint=libtommath|gmp (default libtommath, public domain). Literals, the full arithmetic/bitwise operator set, same-type and cross-type-with-integer comparisons, typeof, ++/--, .toString([radix]), BigInt.asIntN/asUintN, Number(bigint), params/returns/fields/arrays, and BigInt(int|string) all work. Division/modulo by zero throws a catchable Error.

const a = 10n
console.log(a + 20n)              // 30n
console.log(BigInt.asIntN(8, 255n))  // -1n
console.log(Number(a))            // 10

A single-branch T | null uses a presence-flagged nullable-scalar slot ({ i1, T }), so a genuine null is distinguishable from a legitimately-present 0 everywhere — ??, === null, printing, JSON — across locals, params, returns, fields, and Maps. A multi-branch A | B | null is handled by the union box instead.

let present: number | null = 0
let absent: number | null = null
console.log(present ?? 42)      // 0
console.log(absent ?? 42)      // 42

Interfaces, inline {} shapes, and type aliases. A literal's fields are coerced against the declared type wherever one is known — variable annotation, function parameter/return/default, array element type, or nested field — not just the literal's own self-inferred type.

interface Point {
  x: number;
  y: number;
}
type Rect = { width: number; height: number }

Homogeneous arrays, stored as a { ptr, i64 } aggregate.

The Promise<T> type for async values.

Function types, represented as a closure struct { funcPtr, envPtr }.

The Map<K,V> collection, with separate helpers per key/value combination (<string,number>, <string,string>, etc.).

The Set<T> collection.

The same runtime box as any/unknown with a checked member set on top, statically restricted to the declared members at every assignment/call/return boundary. A narrowed local unboxes to the concrete member; an object member to its typed pointer. Usable for a variable, parameter, return value, object field and array element ((number | string)[], and (number | undefined)[] whose absent elements are real undefineds); every write is checked against the member set.

let x: string | number = "hello"
console.log(typeof x)    // string
x = 42
console.log(typeof x)    // number

An object-type intersection collapses at resolveType into one merged ObjectType — member fields concatenated, compatible duplicates deduped — with no runtime tag, unlike a union. & binds tighter than |. Works as a named interface, inline {}, or type alias member, and in variable/param/return/field/array-element positions.

interface HasName { name: string }
interface HasAge { age: number }
const p: HasName & HasAge = { name: "Kyriakos", age: 34 }

A fixed-arity, heterogeneous, positional value stored as a fixed-shape struct. Supports labelled elements ([min: number, max: number]), the tuple literal, constant-index read and assignment, .length (compile-time constant), destructuring (including nested and for-of), and array-shaped rendering. Map/Array/Object.entries() return real [K, V] tuples.

const point: [number, number] = [3, 4]
console.log(point[0])              // 3
const [name, value] = point

Partial/Required/Readonly/NonNullable/Pick/Omit/Record, the general mapped form { [K in keyof T]: V }, keyof, indexed access T[K], and string-literal types — all evaluated at compile time to concrete object types via the monomorphization seam, no runtime representation.

type Clone = { [K in keyof User]: User[K] }

Evaluated at compile time off the monomorphized (concrete) check type — generic type aliases, infer capture, and a structural assignability predicate. Nested conditionals are right-associative.

type ElementOf<T> = T extends Array<infer E> ? E : T
const one: ElementOf<number[]> = 7
const raw: ElementOf<string> = "hi"

V1 (default) is monomorphization — one specialized implementation per distinct combination of concrete types actually used. Covers function identity<T>, interface Box<T>, class Box<T>, and multiple type parameters <K, V>. <T extends X> constraints are parsed and enforced (structural width subtyping). V2 /** @erased */ compiles a generic function's body once, with no name mangling.

function identity<T>(x: T): T {
  return x;
}
console.log(identity(42));       // 42
console.log(identity("hello"));  // hello

A string index signature types a dictionary of arbitrary string keys, backed by a map.

interface Scores {
  [player: string]: number;
}
const scores: Scores = { alice: 10, bob: 7 };
scores["carol"] = 12;

Derives a type from an existing value without restating its shape, usable as a type alias, an inline annotation, or a parameter/return type.

const config = { host: "localhost", port: 8080 };
type Config = typeof config;
const staging: Config = { host: "staging", port: 9090 };

Parsed as a left-associative postfix on any expression; as const and satisfies T are likewise identity.

Template literal types parse in a type position (no-substitution, multi-substitution, and []-suffixed forms) and resolve to `string` — the literal pattern isn't narrowed or enforced, the same simplification string-literal types use.

The readonly array-type modifier parses in variable/parameter/return/field positions.

declare ambient declarations describe types the environment provides; carrying no implementation, they are parsed and erased.

declare const BUILD_ID: string;
declare function nativeHook(x: number): number;
declare module "vendor-lib" {
  export function doThing(): void;
}

The default strict lane rejects a program TypeScript rejects for these type errors, reporting tsc's code, message and position. -compat=js compiles the same program as JavaScript.

let n: number = "x"
// klainmain: type error: main.ts: 1:1: type 'string' is not assignable to type 'number'
//   hint: TypeScript rejects this program; -compat=js compiles it as JavaScript