ALL INTELLIGENCE
Hacker News AIT2·Tools

TScert Debuts Sound TypeScript Checker with Lean-Verified Proofs

Original title: TScert: A Sound Core for TypeScript
62AI Score

TScert is a sound type checker for TypeScript that accepts a function only when accompanied by a proof, validated by a checker whose soundness is itself proved in Lean. It does not trust types inferred by TypeScript or related tools, addressing tsc's unsoundness around any, type assertions, unchecked index reads and covariant arrays.

Full Report

Contents6 sections

TScert checks that TypeScript functions are type-safe, and accepts a function only with a proof. A checker whose soundness is proved in Lean validates that proof. It never trusts the types that TypeScript or the proposing tools infer; what it does trust is listed under What acceptance means.

https://github.com/user-attachments/assets/c539cf25-8956-4bd5-88ca-795873acab34

Why

TypeScript's type checker is deliberately unsound in places: any, type assertions, unchecked index reads and covariant arrays let programs that pass tsc still read undefined where a type says string. TScert gives a stronger answer for the code it accepts: for every input that meets its annotations, the function's translation into a formal model never applies an operation to a value it does not fit, and never returns a value outside its result type. A theorem in Lean states that guarantee, and the checker that decides acceptance is the code the theorem is about.

An example

<img src="assets/readme/checker.png" width="110" align="right" alt="The checker, a turnstile with a magnifying glass">

TypeScript accepts this function (under strict, which leaves noUncheckedIndexedAccess off). TScert refuses it:

TYPESCRIPT
export function stale(xs: string[]): string {
  const n = xs.length;
  xs.pop();
  return xs[n - 1]; // past the end after the pop: undefined at run time
}

Abridged output (offsets refer to the example file):

YAML
"status": "unverified"
reject: source expression obligation at [219,228): evidence search failed: no derivation of its return-contract claim
obligation: The available claim for xs[n - 1] is undefined | string. This return requires string.

With the result type stated honestly, string | undefined, TScert accepts it. Both versions are pipeline cases: invalid-array-last-after-pop.ts and afterPop in array-last-element.ts.

How it works

<picture> <source media="(prefers-color-scheme: dark)" srcset="diagrams/architecture-dark.png"> <img src="diagrams/architecture-light.png" alt="Parse, plan and elaborate are trusted on review; propose and search are proposals that may be wrong; check is proved sound and receives the certificate and the same request elaboration produced."> </picture>

A front end on TypeScript's compiler API reads the source and the declarations it uses, and Lean plans its execution. An OCaml program, the producer, proposes the type of every expression and variable; its answers are claims, and none is trusted. Lean translates the function, with those types, into a small formal language (the calculus) whose execution and safety are defined in Lean. An untrusted search proposes a certificate, a derivation that the program meets its types, and the checker validates it against the same translation. The stages describe each step.

What acceptance means

Acceptance proves, of the function's translation into the calculus, that for inputs and a heap meeting their declared types it does not get stuck and does not return a value outside its result type. It may throw or run forever. The theorem is checkUnitJson_safe. Some things are trusted rather than proved:

  • that the translation from TypeScript to the calculus is faithful (reviewed and tested, not proved);
  • that library and host functions behave as their reviewed contracts state;
  • that callers and imports meet their declared types;
  • Lean itself.

The trust surface lists every assumption, and what "verified" means states the guarantee exactly.

Status

TScert is a research project, unfinished by design. Its benchmark is its own front end: at v0.94, 643 of the 686 functions of tools/ verify, each checked in its own unit with what it calls read at its stated signature (census of ae20a6c6, 2026-11-04). The coverage metrics and the status table give the definitions and the dated measurements.

In outline, the supported subset covers:

  • const/let, patterns, if, switch, loops including for...of and for...in, labeled blocks, throw and try/catch/finally;
  • primitives with literal types, arithmetic, comparisons, template literals, typeof, in, instanceof and strict equality;
  • object literals with spreads, records, index signatures, arrays and tuples, optional chaining, enums, and classes with fields, methods and a base class;
  • functions, closures, optional, default and rest parameters, generic functions certified for every admissible type argument, async and await of native promises;
  • declared types: aliases, interfaces, unions, intersections and library types through reviewed contracts.

any is refused, and a type assertion (e as T, e!) decides nothing. Every unsupported form is refused with a reason and a location. The fragment boundary lists what is refused and why.

On the shoulders of

TScert builds on decades of work on types and semantics, among them Appel and McAllester's indexed model for foundational proof-carrying code, Ahmed's semantics of types for mutable state, Wright and Felleisen's syntactic type soundness, Reynolds's parametricity, Abadi and Cardelli's theory of objects, semantic subtyping, JSCert, the ECMAScript specification and Lean 4. REFERENCES lists every work, with what TScert takes from it and where.

(注:更多技术实现细节与完整 API 文档请查阅原项目 README)