Why Your TypeScript 7 Upgrade Broke ESLint, ts-jest, and ts-morph

You installed TypeScript 7, ran your build, and something broke. Maybe ESLint crashed with a cryptic TypeError: Cannot read properties of undefined (reading 'Cjs'). Maybe ts-jest stopped transforming your test files. Maybe your CI pipeline just went red for no reason you can point to.

You're not doing anything wrong. TypeScript 7 shipped tsgo, a genuine Go port of the type-checker, not a rewrite from scratch. But the tools that plug into TypeScript don't talk to the type-checker directly, they talk to a programmatic API. That API isn't stable yet. It lands in 7.1. Until then, a chunk of the ecosystem throws errors the moment you point typescript at the new version.

Here's what's actually happening, which tools are affected, and the fix that gets you the faster type-checking without breaking everything else.

That's the pattern. The rest of this post covers why it works and how to wire it up, tool by tool.

TypeScript's team calls this Project Corsa. The pitch: rewrite the compiler in Go, keep identical type-checking behavior, get roughly 10x faster builds by using real OS threads instead of Node's single-threaded event loop. It shipped as a release candidate on June 18, 2026, with general availability targeted about a month out. We covered the rewrite itself in TypeScript 7 (Project Corsa): What Next.js Devs Need to Know, which explains what changed under the hood and why Microsoft picked Go. This post assumes you already know that part and covers a different problem: what happens when your existing toolchain points at the new compiler.

The detail that gets lost in the "10x faster" headline: this is a port, not a reimplementation with a new API surface. The team moved the existing structure file by file from the old JavaScript codebase (they call it Strada) into Go (Corsa). That preserved identical type-checking semantics, which is genuinely impressive engineering. What it didn't preserve is the programmatic API surface that tools like typescript-eslint depend on to walk your AST and pull type information out of the compiler. That stable API is scheduled for 7.1, not 7.0.

So when you run npm install typescript@7, you get a fast compiler binary. You do not get a drop-in replacement for every place your old TypeScript 6 install was quietly doing double duty as both a CLI tool and a library other tools import at the code level.

This is based on live GitHub issues filed in the weeks around the release candidate, not speculation. If you upgraded and hit an error, it's almost certainly one of these four.

This is the big one. If you have typescript-eslint in your devDependencies with the current published peer range, npm refuses to install alongside typescript@7 at all, because the peer range only allows versions below 6.1.0. That refusal shows up as an ERESOLVE error before you ever run a lint.

Force the install anyway with --force or --legacy-peer-deps and ESLint crashes with TypeError: Cannot read properties of undefined (reading 'Cjs') deep inside typescript-estree. This is a real, reproducible crash tracked as typescript-eslint issue 12518, filed July 8, 2026 and closed as not planned, since the fix is genuinely on the TypeScript 7.1 side, not typescript-eslint's.

If you've never had to untangle an ERESOLVE error by hand, our ERESOLVE Explainer tool parses the exact output above (or your own) and generates the overrides block you need, faster than tracing the dependency tree line by line yourself.

ts-jest mostly survives if you leave typescript pointed at 6.x in node_modules and only use tsgo separately for type-checking. If you try to make ts-jest itself resolve to @typescript/native-preview, it breaks, because ts-jest calls internal Strada APIs that Corsa doesn't expose yet. The error surfaces as a transform failure, not an install failure, which makes it more confusing to diagnose: your tests just start failing with unhelpful stack traces pointing into ts-jest's internals rather than your own code.

ts-morph and any custom AST transformer are in the same boat as typescript-eslint: anything doing deep programmatic type introspection needs the 7.1 API and isn't safe to point at the native preview yet. If your build pipeline includes a custom transformer (code generation, decorator metadata, schema extraction from types), audit it before upgrading, since these tools tend to fail silently or produce subtly wrong output rather than crashing outright.

Monorepos hit their own category of pain. The WordPress Gutenberg team, migrating an 84-package monorepo, logged a real issue in March 2026: tsgo drops generic type parameters from JSDoc @typedef declarations that use @template, which matters if you're a JS-plus-JSDoc codebase rather than pure .ts. They also found that skipLibCheck: true doesn't suppress certain parse-level errors from third-party .d.ts files, so some previously-silent type-check noise becomes build-breaking noise. tldraw opened a similar tracking issue for their own 44-tsconfig monorepo.

A separate compatibility survey published in April 2026 tested 15 popular pipeline tools against the native preview and found 9 of them call Strada API functions that no longer exist. That's the concrete version of the abstract problem above: most teams need a side-by-side setup rather than a straight swap, and that ratio (9 out of 15) is a useful gut check for how far the ecosystem still has to go before 7.1 closes the gap.

Here's the setup that gets you fast type-checking without breaking your existing tools. It takes about five minutes to wire up.

You get the speed where it actually helps (the fast CI feedback loop) without asking every downstream tool to understand a compiler API that doesn't exist yet.

Even if none of your tools break, TypeScript 7 hard-adopts some strict defaults that catch people who skipped the TypeScript 6 release entirely. These aren't Corsa-specific bugs, they're default changes that happen to surface at the same time as the compiler rewrite.

Audit your tsconfig before you upgrade even the type-checking-only tsgo binary. If you'd rather start from a config that's already compatible with these defaults, the TSConfigBuilder tool generates one from the ground up, useful for new projects or as a reference when auditing an existing config.

Wait for 7.1's stable programmatic API before you drop the side-by-side setup and point everything at typescript@7 directly. If your project genuinely doesn't use typescript-eslint, ts-morph, or custom transformers, and you're just running tsc for type-checking and emit, you can move to 7.0 straight away once it hits general availability. Most real-world codebases aren't that lucky, and the side-by-side setup above costs you nothing while you wait.

For the broader migration picture, including the tsconfig audit steps and CI rollout pattern in more depth, see our full TypeScript 7 Migration Guide.