TypeScript 7.0: Compiler Native Go yang 10x Lebih Cepat — Panduan Migrasi Praktis

Bayangkan ini: kamu push PR, CI jalan, lalu kamu nunggu. Dan nunggu. Type-check 700 file TypeScript makan waktu hampir 7 detik di proyek kecil, puluhan detik di monorepo, dan kalau codebase-mu sebesar VS Code — 125 detik. Dua menit lebih cuma buat ngecek tipe.

Pada 8 Juli 2026, Microsoft merilis TypeScript 7.0 — dan angka 125 detik itu runtuh jadi 10,6 detik. Rahasianya? Compiler TypeScript kini ditulis dalam Go, berjalan sebagai binary native, dan mengecek file-file-mu secara paralel. Bukan 10% lebih cepat. Bukan 2x. Klaim resminya: 8 sampai 12 kali lebih cepat.

Terdengar seperti hype rilis besar? Wajar kalau skeptis. Benchmark vendor memang selalu diukur di kondisi ideal. Tapi kabar baiknya: komunitas sudah mengujinya di proyek nyata sejak fase preview — dari aplikasi React Native sampai monorepo Next.js 728 file — dan hasilnya konsisten: jauh lebih cepat, error yang dilaporkan identik, nyaris tanpa perubahan kode.

Artikel ini adalah panduan migrasi praktis TypeScript 7.0 untuk developer Indonesia: apa yang sebenarnya berubah (dan apa yang tidak), angka benchmark yang jujur — termasuk kenapa proyek kecilmu mungkin "cuma" 2–3x lebih cepat — langkah migrasi 30 menit, jebakan ekosistem yang wajib kamu tahu (ada satu yang bisa merusak linting-mu), dan decision matrix: kapan migrasi sekarang, kapan tunggu 7.1.

Yang Sebenarnya Terjadi: Port, Bukan Rewrite

Hal pertama yang perlu diluruskan: TypeScript 7.0 bukan compiler baru. Ini adalah hasil Project Corsa — port baris-per-baris (methodical port) dari codebase TypeScript yang sudah ada ke bahasa Go, dikerjakan di repo staging microsoft/typescript-go. Microsoft sengaja memilih port setia ketimbang rewrite total, supaya semantik type-checking-nya identik dengan TypeScript 6.0. Dari ~20.000 test case compiler, sekitar 6.000 menghasilkan error di TS 6.0 — dan TS 7 cocok dengan semuanya kecuali sekitar 74 kasus. Artinya: kalau kodemu lolos di 6.0, hampir pasti lolos di 7.0 dengan error yang sama persis, di file yang sama, baris yang sama, kode error yang sama.

Lalu kenapa Go? Tiga alasan teknis:

1. Binary native, tanpa startup Node.js. Compiler lama berjalan di atas Node.js/V8 — setiap pemanggilan tsc harus menunggu runtime JavaScript booting dulu. Compiler Go dikompilasi jadi binary machine code langsung. Tidak ada interpreter yang perlu dinyalakan.
2. Paralelisme beneran. Compiler lama itu single-threaded. Go punya goroutine yang ringan — TS 7 bisa menyebar type-checking ke banyak CPU core sekaligus. Di mesin CI 8-core, ini perbedaan besar.
3. Model memori yang lebih bisa diprediksi. Heap V8 dengan garbage collector-nya terkenal boros untuk workload compiler yang alokasi-nya masif. Hasilnya: Microsoft mengukur pemakaian memori agregat 6–26% lebih rendah di proyek benchmark mereka.

Satu catatan penting soal penamaan yang membingungkan banyak orang: selama fase preview (2025 sampai pertengahan 2026), compiler ini didistribusikan sebagai package npm @typescript/native-preview dengan binary bernama tsgo. Sejak 7.0 RC, package typescript yang biasa kamu install SUDAH adalah compiler native, dan binary-nya tetap tsc. Jadi kalau kamu baca tutorial lama yang menyuruh npm install @typescript/native-preview atau npx tsgo, itu dokumentasi era preview. Untuk instalasi stabil hari ini, cukup npm install -D typescript@^7 seperti biasa. Repo staging typescript-go sendiri sudah diarsipkan pada 1 September 2026 dengan pesan "proses port native selesai".

Dan satu hal lagi yang perlu ekspektasinya dijaga: TypeScript 7.0 tidak membawa sintaks atau fitur type system baru sama sekali. Tidak ada operator baru, tidak ada keyword baru. Semua energi rilis ini dihabiskan untuk porting. Fitur bahasa baru dilanjutkan di lini 7.x setelahnya. Ini rilis infrastruktur — dan justru itu yang membuatnya aman.

Timeline Singkat: Kenapa Ada TypeScript 6.0?

Buat yang ketinggalan kereta: TypeScript 6.0 rilis 23 Maret 2026 dan merupakan rilis terakhir di atas codebase JavaScript. Microsoft memposisikannya sebagai bridge release — rilis jembatan. Tugasnya: membalik default yang akan berlaku di 7.0 dan mengubah deprecation lama menjadi error, supaya migrasi 6→7 tidak mengejutkan.

Artinya jalur migrasi yang didukung resmi adalah: 5.x → 6.0 (bereskan deprecation) → 7.0 (ganti binary). Kalau kamu masih di 5.9, jangan lompat langsung. Nanti di bagian tutorial kita bahas kenapa urutan ini penting.

Setelah 7.0 GA (8 Juli 2026), yang ditunggu berikutnya adalah TypeScript 7.1 — rilis yang akan membawa stable programmatic API. Kenapa ini penting? Kita bahas di bagian jebakan ekosistem, karena ini satu-satunya alasan kuat untuk menunda migrasi.

Angka yang Jujur: 10x Itu Nyata, Tapi Tidak Merata

Mari bedah klaim "8–12x lebih cepat" dengan data dari dunia nyata, bukan cuma brosur Microsoft.

Benchmark resmi Microsoft memakai codebase VS Code (~1,5 juta baris kode): full build tsc 125,7 detik → compiler native 10,6 detik. Itu ~11,9x. Di proyek benchmark mereka yang lain, klaim umumnya "sering sekitar 10x lebih cepat dari TypeScript 6.0".

Benchmark komunitas memberi gambaran yang lebih bernuansa:

• Monorepo Next.js, 728 file (diuji developer di dev.to, Windows 11, Node 24): cold check tsc 6.0.3 makan 6,7 detik → tsgo 2,1 detik (~3,2x). Warm check (dengan cache incremental): 1,9 detik → 0,7 detik (~2,7x).
• Aplikasi React Native (diuji Oktober 2026, JavaScript in Plain English): 4–7x lebih cepat, dengan error yang dilaporkan persis sama. Penulisnya mencatat React Native adalah kandidat ideal karena Metro memakai Babel untuk build — TypeScript di sana cuma dipakai untuk type-check dan editor, jadi compiler baru mempercepat CI dan editor tanpa menyentuh cara app di-build. Low-risk change.
• Proyek kecil (~86 package, puluhan komponen): cuma ~1,4x lebih cepat (3,03 detik → 2,10 detik). Penulisnya jujur: di proyek sekecil itu, sebagian besar wall-clock time habis untuk startup proses dan I/O file, bukan algoritma type-checking yang dipercepat Go. Klaim 10x adalah pernyataan tentang inner loop compiler pada graf file yang besar.

Pola ini penting dipahami: speedup berbanding lurus dengan ukuran codebase. Proyek kecil (<200 file) mungkin cuma merasakan 1,5–3x. Proyek menengah (500–1000 file) di kisaran 3–6x. Monorepo besar dan codebase jutaan LOC yang mendekati 10x. Kabar baiknya: error yang dilaporkan identik di semua pengujian — termasuk satu pengujian yang sengaja merusak kode (string di-assign ke field bertipe number), kedua compiler melaporkan TS2322 di file, baris, dan kolom yang sama.

Satu detail kecil dari pengujian komunitas yang layak dicatat untuk pipeline CI-mu: ada laporan bahwa compiler native keluar dengan exit code 1 saat ada type error, sementara tsc lama keluar dengan kode 2. Kebanyakan setup CI cuma mengecek "non-zero" jadi tidak masalah — tapi kalau pipeline-mu branching berdasarkan kode exit spesifik, ini perlu disesuaikan.

Takeaway praktis: ukur dulu baseline di proyekmu sendiri sebelum dan sesudah (caranya ada di tutorial di bawah). Jangan kecewa kalau "cuma" 3x — di CI yang jalan ratusan kali sehari, 3x tetap berarti antrean PR yang jauh lebih pendek.

Yang Berubah di Default: Bagian Ini yang Bikin Error Baru

Karena TS 7.0 adalah port yang setia dari 6.0, "breaking changes"-nya sebenarnya warisan dari bridge release 6.0. Tapi karena banyak tim yang lompat dari 5.x, mereka baru merasakannya sekarang. Ini daftarnya:

Default baru: strict: true dan target/modul modern. Di 7.0, mode strict dan default esnext aktif tanpa perlu ditulis. Kalau tsconfig.json-mu selama ini tidak menulis strict secara eksplisit (atau lebih parah: mengandalkannya false), siap-siap dapat hujan error baru yang sebenarnya adalah bug laten yang selama ini lolos.

Deprecation lama kini jadi hard error. Ini daftar yang paling sering menggigit:

Jalan pintas darurat kalau kamu kepepet deadline: "ignoreDeprecations": "6.0" di tsconfig menunda error ini. Tapi anggap itu perban, bukan obat — targetnya tetap dibereskan, karena opsi-opsi itu memang akan hilang permanen.

Knob paralelisme baru. Compiler native memperkenalkan flag untuk mengatur worker paralel:

• --checkers — jumlah checker worker (default 4)
• --builders — worker untuk project-reference build
• --singleThreaded — paksa single-thread (berguna untuk debugging atau mesin kecil)

Untuk kebanyakan kasus, default-nya sudah tepat. Sentuh ini hanya kalau kamu benchmarking atau mesin CI-mu punya core sangat banyak/sedikit.

Tutorial: Migrasi dalam 30 Menit

Oke, ke bagian praktis. Skenario: kamu punya proyek Node.js/TypeScript (misalnya backend Nest.js atau frontend Next.js — stack yang umum di Indonesia), saat ini di TypeScript 5.x. Target: TypeScript 7.0 stable, CI tetap hijau.

Langkah 0 — Ukur baseline (5 menit)

Jangan skip ini. Tanpa angka sebelum, kamu tidak bisa membuktikan sesudah.

# Pastikan tidak ada cache incremental yang mengotori pengukuran
rm -f tsconfig.tsbuildinfo

# Ukur 3x, ambil rata-rata
time npx tsc --noEmit -p tsconfig.json
time npx tsc --noEmit -p tsconfig.json
time npx tsc --noEmit -p tsconfig.json

Catat angkanya. Ini "foto sebelum".

Langkah 1 — Naik ke TypeScript 6.0 dulu (10 menit)

Ini jembatan yang disiapkan Microsoft. Di 6.0, deprecation di atas sudah jadi error (bisa di-snooze pakai ignoreDeprecations), jadi kamu membereskan masalah konfigurasi sebelum ganti compiler.

npm install -D typescript@^6.0
npx tsc --noEmit -p tsconfig.json

Perbaiki semua error yang muncul — 99% akan berasal dari tabel deprecation di atas:

// tsconfig.json — contoh perbaikan tipikal
{
  "compilerOptions": {
    // "moduleResolution": "node",  // HAPUS — deprecated
    "moduleResolution": "bundler",   // untuk proyek Vite/Next.js/Webpack
    // "baseUrl": ".",               // HAPUS kalau tidak pakai paths
    "paths": { "@/*": ["./src/*"] },
    "target": "ES2022",
    "strict": true                   // eksplisit lebih baik daripada mengandalkan default
  }
}

Untuk proyek Node.js backend (Nest.js/Express), moduleResolution: "nodenext" biasanya pilihan yang benar; untuk proyek bundler (Vite, Next.js), "bundler".

Langkah 2 — Update ke TypeScript 7.0 (2 menit)

npm install -D typescript@^7.0
npx tsc --version  # harusnya 7.x

Tidak ada package baru. Tidak ada binary baru. tsc yang kamu panggil sekarang adalah binary Go. Kalau kamu masih menemukan tutorial yang menyuruh install @typescript/native-preview, abaikan — itu artefak era preview.

Langkah 3 — Hapus artefak incremental lama (1 menit)

Penting dan sering kelupaan: file *.tsbuildinfo yang dihasilkan tsc JavaScript tidak kompatibel dengan compiler native. Kalau tidak dihapus, kamu bisa dapat perilaku incremental build yang aneh.

# hapus semua tsbuildinfo di proyek (termasuk monorepo)
find . -name "*.tsbuildinfo" -not -path "*/node_modules/*" -delete

Sekalian tambahkan *.tsbuildinfo ke .gitignore kalau belum ada.

Langkah 4 — Verifikasi: kecepatan dan kesamaan error (5 menit)

time npx tsc --noEmit -p tsconfig.json
time npx tsc --noEmit -p tsconfig.json
time npx tsc --noEmit -p tsconfig.json

Bandingkan dengan baseline Langkah 0. Lalu uji kesetiaan: kalau proyekmu punya error yang diketahui (atau sengaja bikin satu di branch test), pastikan pesan error-nya identik — file, baris, kode error sama.

Langkah 5 — Update pipeline CI (5 menit)

Contoh untuk GitHub Actions — sebenarnya tidak ada yang berubah dari sisi command, tapi ini momen yang tepat untuk memastikan caching benar:

- name: Type check
  run: npx tsc --noEmit -p tsconfig.json

Pastikan step ini tidak bergantung pada exit code spesifik 2 untuk mendeteksi type error (ingat catatan exit code 1 vs 2 di atas) — cek cukup "non-zero = gagal".

Langkah 6 — Editor: aktifkan language server baru

Kecepatan di terminal itu setengah cerita; separuhnya lagi adalah editor. TypeScript 7 membawa language server berbasis LSP yang multithreaded — pengganti tsserver lama. Di VS Code, install ekstensi "TypeScript Native Preview" (nama bersejarah dari era preview; fungsinya adalah mengaktifkan server native). Editor lain (Neovim, Zed, dll.) mengonsumsinya via LSP standar.

Efek yang dirasakan: hover, go-to-definition, dan — yang paling terasa — tidak ada lagi "loading..." panjang saat membuka proyek besar pertama kali. Red squiggle muncul jauh lebih cepat setelah kamu mengetik.

Jebakan Ekosistem: Satu-satunya Alasan Menunda

Sampai sini semuanya terdengar mulus. Sekarang bagian yang tidak ada di brosur: TypeScript 7.0 belum punya stable programmatic API. Compiler Go belum mengekspos API yang bisa di-embed — itu dijadwalkan untuk 7.1, beberapa bulan setelah 7.0.

Dampaknya konkret dan harus kamu audit sebelum migrasi:

• typescript-eslint: peer dependency-nya mensyaratkan typescript <6.1.0. Install typescript@7 di sampingnya = konflik peer dan type-aware linting crash. Ini jebakan paling umum.
• Template checker framework: vue-tsc, svelte-check (mode default), Astro check, dan Angular template checking — semuanya memakai compiler API, semuanya belum bisa jalan di atas TS 7.0.
• ts-morph, ts-jest, dan semua tool yang import { ... } from "typescript" — out sampai API stabil tersedia.

Strategi yang dipakai tim-tim early adopter: dual install. Pakai TypeScript 7 untuk type-check (tsc --noEmit), tapi pertahankan compiler JS lama khusus untuk perkakas yang butuh API — misalnya via alias:

npm install -D typescript@^7.0
npm install -D typescript-api@npm:typescript@^6.0  # untuk tooling yang butuh JS API

Lalu di konfigurasi tool (misalnya ts-jest atau script ts-morph), arahkan ke package alias tersebut. Tidak elegan, tapi bekerja — dan ini pola sementara sampai 7.1 mendarat.

Catatan terkait: ESLint 10 (rilis 6 Februari 2026) menghapus total sistem konfigurasi lama eslintrc — .eslintrc.* dan .eslintignore tidak lagi dibaca, dan ESLINT_USE_FLAT_CONFIG tidak dikenali. Kalau migrasi TS 7-mu berbarengan dengan upgrade ESLint, pastikan konfigurasimu sudah format flat (eslint.config.js). Dua migrasi besar sekaligus memang melelahkan, tapi format flat adalah satu-satunya format yang didukung ke depan.

Kapan Migrasi Sekarang, Kapan Tunggu 7.1

Decision matrix jujur, bukan ajakan membabi-buta:

Migrasi sekarang kalau:

• Proyekmu memakai TypeScript murni sebagai type-checker (noEmit: true) dan build di-handle Vite/esbuild/SWC/Babel — ini pola mayoritas proyek modern Indonesia. Kamu dapat semua kecepatan tanpa menyentuh satu pun jebakan API.
• CI-mu lambat karena type-check, dan antrean PR menumpuk. Bahkan 2–3x sudah transformatif di skala ratusan run per hari.
• Kamu di React Native / Expo: Metro tidak memakai tsc untuk build, jadi risikonya minimal.

Tunggu 7.1 kalau:

• Kamu berat di Vue, Svelte, Astro, atau Angular dengan template checking di CI — tooling-nya belum kompatibel.
• Type-aware linting (typescript-eslint dengan aturan berbasis tipe) adalah gerbang wajib di pipeline-mu dan kamu tidak mau repot dual install.
• Kamu maintainer library/tooling yang memakai compiler API secara programatik (ts-morph, custom transformer, codemod).

Untuk proyek kecil (<200 file): migrasi tetap aman dan mudah, tapi ekspektasikan gain 1,5–3x, bukan 10x. Lakukan kalau kamu memang sedang upgrade dependensi; jangan jadikan proyek khusus.

Checklist Produksi

Sebelum merge PR migrasi ke main, centang ini:

• Baseline waktu type-check tercatat (sebelum vs sesudah, 3x run)
• moduleResolution, baseUrl, target, dan format emit sudah sesuai tabel migrasi
• Semua *.tsbuildinfo lama dihapus; entri .gitignore ditambahkan
• npm run typecheck (atau setara) hijau di CI
• Pipeline CI tidak branching pada exit code spesifik tsc
• Audit perkakas berbasis compiler API: typescript-eslint, vue-tsc/svelte-check, ts-morph, ts-jest — putuskan: dual install atau tunda
• Konfigurasi ESLint sudah format flat kalau sekalian upgrade ke v10
• Ekstensi VS Code "TypeScript Native Preview" (language server baru) dianjurkan ke tim
• ignoreDeprecations — kalau dipakai, buat tiket follow-up untuk menghapusnya

Penutup: Rilis Paling "Membosankan" yang Paling Berdampak

TypeScript 7.0 adalah rilis yang aneh: tidak ada fitur bahasa baru untuk di-demo di konferensi, tidak ada sintaks yang bisa dipamerkan di Twitter. Yang ada hanyalah pekerjaan infrastruktur yang membosankan — mem-port ratusan ribu baris kode ke Go, baris demi baris, sambil menjaga 20.000 test tetap hijau.

Tapi justru rilis "membosankan" seperti inilah yang paling mengubah hari kerja developer. Setiap detik yang hilang menunggu type-check adalah detik di mana fokus terputus — dan kalau dikali ratusan run CI sehari dikali seluruh tim, 8–12x bukan sekadar angka benchmark. Itu jam kerja yang kembali.

Mulai dari Langkah 0 hari ini: ukur baseline-mu. Angka itu — bukan klaim Microsoft, bukan artikel ini — yang akan memberitahumu apakah migrasi ini worth it untuk proyekmu. Kemungkinan besar, jawabannya ya.

Fakta dalam artikel ini diverifikasi per Oktober 2026 dari pengumuman resmi Microsoft/TypeScript, repositori microsoft/typescript-go, dan benchmark independen komunitas (dev.to, JavaScript in Plain English, dan laporan adopsi open-source). Status programmatic API (menunggu 7.1) dapat berubah — cek catatan rilis resmi sebelum mengambil keputusan final untuk proyekmu.

Bonus: Simulasi Hemat Waktu CI di Tim Nyata

Biar abstraknya hilang, mari hitung kasar untuk tim backend tipikal di Indonesia: 6 developer, monorepo Nest.js + shared packages, ~900 file TypeScript, CI jalan di GitHub Actions setiap push dan PR.

Asumsi realistis (bukan klaim 10x, pakai angka tengah benchmark komunitas untuk ukuran ini: ~4x):

Hemat ~6,6 jam waktu tunggu CI murni per bulan — dan itu belum menghitung efek compounding: developer yang tidak menunggu lama cenderung push dalam batch lebih kecil dan lebih sering, yang membuat review PR lebih cepat juga. Di runner berbayar (GitHub Actions menit), 18 menit per hari × 22 hari ≈ 400 menit/bulan yang tidak lagi dibayar. Kecil per bulan, tapi migrasi ini biayanya nyaris nol — sekali jalan, hemat selamanya.

Rumus cepat untuk proyekmu sendiri: (waktu_lama - waktu_baru) × run_per_hari × hari_kerja. Kalau hasilnya di atas 2 jam/bulan, migrasi ini sudah "membayar" waktu 30 menit yang kamu habiskan menjalankannya — di minggu pertama.

Catatan Khusus Monorepo (Turborepo / Nx / Project References)

Monorepo adalah tempat compiler native bersinar paling terang — dan tempat jebakannya paling dalam. Dua hal spesifik:

1. Project references + --build justru dapat dobel. Flag --builders mengatur worker paralel untuk project-reference build. Di monorepo dengan puluhan package, kombinasi --checkers (paralel dalam satu proyek) dan --builders (paralel antar proyek) memberi speedup terbesar yang pernah diukur komunitas. Pastikan composite: true dan declaration: true tetap ter-set di tiap package — itu syarat project references, tidak berubah di 7.0.

2. Satu tsbuildinfo basi bisa meracuni semua package. Karena artefak incremental tidak kompatibel antar compiler, di monorepo kamu harus menghapusnya di semua package sekaligus (perintah find di Langkah 3 sudah mencakup ini). Gejala kalau kelupaan: build yang "sukses" tapi sebenarnya memakai info basi, atau error aneh yang hilang-timbul. Kalau ragu, hapus semuanya dan biarkan rebuild dari nol sekali — dengan compiler 10x lebih cepat, rebuild penuh pun tidak menyakitkan lagi. Ironis, tapi benar.

FAQ

Apakah saya harus mengubah kode TypeScript saya? Tidak. Type-checking-nya identik secara struktural dengan 6.0. Yang mungkin perlu diubah hanya tsconfig.json (bagian deprecation) dan tidak ada satu baris pun kode aplikasimu. Ini migrasi toolchain, bukan migrasi bahasa.

Apakah tsgo masih perlu di-install? Tidak, untuk penggunaan stabil. tsgo adalah nama binary era preview dari package @typescript/native-preview. Sejak 7.0 RC, package typescript biasa sudah berisi compiler native dan binary-nya bernama tsc seperti biasa. Satu-satunya alasan masih melihat nama tsgo adalah dokumentasi lama atau channel nightly bleeding-edge.

Bagaimana dengan Deno dan Bun? Keduanya menjalankan TypeScript dengan cara mereka sendiri (Deno memakai SWC-based transpile + type-check opsional; Bun memakai transpiler internal dan tidak type-check). TS 7.0 paling berdampak pada proyek Node.js klasik dan CI yang memanggil tsc langsung. Kalau toolchain-mu tidak pernah memanggil tsc, kamu tidak akan merasakan apa-apa — dan tidak perlu melakukan apa-apa.

Apakah aman dipakai di produksi sekarang (Oktober 2026)? Untuk type-checking, ya — 7.0 sudah GA sejak 8 Juli 2026, staging repo diarsip 1 September 2026 sebagai tanda port selesai, dan ribuan proyek sudah mengujinya sejak fase preview dengan error yang identik. Yang belum aman adalah programmatic API (untuk tooling) — itu menunggu 7.1. Bedakan dua hal ini dan keputusanmu jadi jelas.

Bisakah saya coba dulu tanpa commit penuh? Bisa, dan ini pola yang dianjurkan. Install dua versi berdampingan: typescript@^7 untuk eksperimen dan versi lamamu yang tetap dipakai CI. Bandingkan output error-nya file per file. Atau manfaatkan package @typescript/typescript6 (entry point tsc6) untuk menjalankan keduanya dalam satu mesin. Tidak cocok? Rollback-nya cuma npm install -D typescript@<versi-lama> — tidak ada yang berubah di kodemu.

Apakah ini berarti JavaScript "kalah" dari Go? Tidak — ini bukan soal bahasa, ini soal workload. Compiler adalah program yang sangat cocok untuk kompilasi native dan paralelisme: parse jutaan token, bangun graf, cek tipe di banyak file independen. V8/Node.js hebat untuk I/O-bound server, tapi single-threaded event loop memang bukan arsitektur ideal untuk type-checking paralel. Microsoft memilih Go juga karena strukturnya memungkinkan port nyaris baris-per-baris — kalau dipilih Rust, port setianya akan jauh lebih sulit. Keputusan engineering yang pragmatis, bukan perang bahasa.

Kapan 7.1 rilis dan apa yang dibawanya? Jadwal pastinya mengikuti irama rilis TypeScript (biasanya tiap ~3 bulan), jadi perkiraan wajarnya akhir 2026. Yang dikonfirmasi: stable programmatic/embeddable API — inilah yang membuka kembali typescript-eslint type-aware, vue-tsc, svelte-check, ts-morph, dan ts-jest di atas compiler native. Kalau kamu menunda migrasi karena alasan ini, tandai kalendermu untuk cek catatan rilis 7.1.