TypeScript 7.1 Beta: Compiler API Returns, Vue and Svelte Go First-Class

TypeScript 7.0 landed in July and broke the ecosystem on purpose. The Go-based native rewrite shipped without a compiler API, stranding Vue, Svelte, Angular, and ts-morph on TypeScript 6 for three months. That was the price of the architecture. TypeScript 7.1 Beta, released October 20, pays off that debt — and it does more than restore what was removed.

The Compiler API Is Back — Rebuilt, Not Revived

The old monolithic compiler API is not coming back. What TypeScript 7.1 ships instead is a set of focused entry points:

• typescript/sync — synchronous compiler client
• typescript/async — Promise-based equivalent
• typescript/fs — request-scoped file systems
• typescript/ast — syntax tree types, plus /is and /factory submodules

These previously sat behind an unstable prefix. That prefix is now gone, and Microsoft has committed to backward compatibility throughout the 7.x release cycle. Tools like ts-morph, ESLint’s type-aware rules, and any internal tooling that compiles TypeScript programmatically can now port off TypeScript 6.

The new API uses the using keyword for resource management:

import { API } from "typescript/sync";

using api = new API();
using program = api.createProgram(fileNames, options);
const emitResult = program.emit();

Resources are disposed automatically when they fall out of scope — no more dangling compiler instances leaking memory.

Content Mappers: Vue and Svelte Are Now First-Class

This is the headline for framework developers. Content mappers are a new, official plugin mechanism that lets a package hand TypeScript a virtual view of a non-standard file — a .vue component, a .svelte file, an MDX page — with source mappings back to the original. TypeScript errors point at the right line. The separate vue-tsc binary becomes unnecessary.

Configuration goes in tsconfig.json:

{
  "contentMappers": [
    {
      "package": "@vue/content-mapper",
      "extensions": [".vue"],
      "options": { "target": 3.5 }
    }
  ]
}

Mappers run as separate processes and only when explicitly enabled. The CLI flag --runExternalCode is required — TypeScript is explicit that mappers are arbitrary executables and you are opting in.

Vue Language Tools v4 alpha has already ported to this system. The real-world numbers from the Directus admin app — 581 Vue components across 882 TypeScript files — tell the story: type checks dropped from 14.19 seconds to 3.10 seconds, a 4.6x speedup.

Svelte, Astro, and Angular tooling are not there yet. The recommendation is to keep TypeScript 6 and 7 installed side by side until their framework tooling ships stable 7.1 builds. The RC drops November 10 — that is the signal to start planning.

ES2026 Target Is Stable

TypeScript 7.1 makes --target es2026 stable. The additions worth knowing about:

• Math.sumPrecise() — accurate floating-point summation
• Error.isError() — reliable cross-realm error detection
• Iterator helpers: zip(), chunks(), join(), includes()
• Map.prototype.getOrInsert() — cleaner map initialization patterns
• Uint8Array.toBase64() and toHex() — encoding helpers built into the platform

Library authors who have been pinning "lib": ["esnext"] and accepting undefined behavior at the edges can now target es2026 with confidence.

The Breaking Change to Check First

TypeScript 7.1 tightens constraints on distributive conditional types. If you have shared type utilities that look like this:

type Show<A extends number, B extends A> = `${B} extends ${A}`;
type Issue<A extends number, B extends A> =
  A extends B ? never : Show<A, B>;

TypeScript 7.1 will error on the second type: in the distributed branch, B is only assignable to the non-distributed form of A, and the constraint no longer satisfies. The fix is usually to remove the now-redundant constraint or add an explicit check. This surfaces most often in shared type packages inside monorepos — fix those before downstream consumers upgrade.

Performance: What to Expect

TypeScript 7.1 also reverses a memory regression from 7.0. Across Microsoft’s benchmarks on real codebases: mui-docs runs 1.9x faster with 49.6% less memory, sentry comes in at 1.3x faster with 20.8% less memory, and vscode itself lands at 1.2x faster with 17.2% less memory. Application code typically falls in the 13–17% improvement range; documentation-heavy codebases with wide union types see more.

What to Do Now

Install the beta on a branch:

npm install -D typescript@beta

Run tsc --noEmit across your packages. Triage into two buckets: distributive type parameter failures (fix in shared packages first) and DOM typing changes (compare against 7.0). Get a clean pass before the RC on November 10 — that is the real deadline before stable lands November 24.

TypeScript 7.0 made a defensible architectural call and accepted three months of ecosystem pain. TypeScript 7.1 is where that bet starts paying off. The question now is how fast Vue Language Tools, Svelte, and Angular ship their 7.1 builds — the compiler is ready, the ecosystem needs to catch up.