tsrs provides diagnostics, hover, go to definition, references, rename, completions with auto-imports, code fixes and formatting through the TypeScript 7 language-server protocol. The recorded 0.19.0 beta validation passes 4,092 of 4,562 fourslash groups; see known gaps and the compatibility table.
tsrs --lsp -stdio speaks the same protocol as tsgo --lsp -stdio (Go's flag parsing: -stdio and --stdio both
work; only stdio is supported, like Go). Build it with cargo build --profile dev -p tsrs_cli (binary
target/debug/tsrs) or install the npm package (tsrs, binary tsrs). The configurations below follow the
editors' documented mechanisms.
VS Code — the TypeScript 7 extension (TypeScriptTeam.native-preview, source in
ts-ref/packages/vscode-typescript) starts <tsdk>/tsgo --lsp --stdio (tsgo.exe on Windows) when
js/ts.tsdk.path points at a directory that contains an executable named tsgo or tsc (.exe on Windows;
src/util.ts: tsdkConfigSources, packagedExeBaseNames).
Since 0.20.0, the package includes tsdk/tsgo for macOS and Linux. Install it with
pnpm add -D [email protected] and commit this .vscode/settings.json so each teammate's editor uses the
version in the project's lockfile:
The native tsrs (tsrs.exe on Windows) and default libraries ship together at each @tsrs/<platform>
package root. The CLI and Node API resolve tsrs[.exe]. Version 0.20.1 adds an identical tsgo.exe to Windows
packages for VS Code's native SDK discovery.
On Windows, use the native platform package's root directory. The x64 example below uses
@tsrs/win32-x64 as a direct optional dependency at the same version as tsrs, so npm and pnpm both expose
the project-local path. Keep both packages at the same version when upgrading:
pnpm add -O --save-exact @tsrs/[email protected]Use these VS Code settings on Windows:
{
"js/ts.experimental.useTsgo": true,
"js/ts.tsdk.path": "./node_modules/@tsrs/win32-x64"
}On Windows ARM64, use @tsrs/win32-arm64 (0.25.0 and later) in both places.
The extension asks for workspace trust and consent before running a workspace SDK. Its automatic package
resolver is specific to @typescript packages; pointing at the native package directory uses its executable
discovery instead. The macOS/Linux tsrs/tsdk launcher delegates to the same platform binary, just like
pnpm exec tsrs. Neither layout adds a tsgo command to node_modules/.bin.
For an older npm release or a local build on macOS/Linux, create a symlink instead:
mkdir -p ~/.tsrs-tsdk && ln -sf "$PWD/target/debug/tsrs" ~/.tsrs-tsdk/tsgoThen set js/ts.tsdk.path in user settings to that directory's absolute path, such as /Users/<you>/.tsrs-tsdk.
Run "TypeScript 7: Restart Server" (or reload the window); the output channel names the executable it started.
Content mappers (js/ts.contentMappers.enabled) run in trusted workspaces, as they do for tsrs -p and tsrs -b.
Neovim (0.11+, built-in client):
vim.lsp.config('tsrs', {
cmd = { 'tsrs', '--lsp', '-stdio' }, -- or the absolute path to target/debug/tsrs
filetypes = { 'typescript', 'typescriptreact', 'javascript', 'javascriptreact' },
root_markers = { 'tsconfig.json', 'jsconfig.json', 'package.json', '.git' },
})
vim.lsp.enable('tsrs')Disable other TypeScript servers for the same buffers (e.g. ts_ls, vtsls) to avoid duplicate results.
Verified headless (Neovim 0.11.6, nvim --headless --clean -u init.lua, scratch HOME, no plugins): the client
attaches, the type error of the opened file arrives as a diagnostic, and hover returns the quick info.
:checkhealth vim.lsp shows the attached client; vim.lsp.set_log_level('debug') logs the protocol.
What to expect: diagnostics are pull-based (textDocument/diagnostic; both clients support it) and tsconfig errors
are pushed; see known gaps for unsupported features and
memory management for program, checker and file-version lifetimes.
Editor integrations can obtain a TypeScript 7 Node API session through the language server:
custom/initializeAPISession returns a pipe (a private Unix socket or Windows named pipe), and API.fromLSPConnection({ pipe }) from the package's
tsrs/async client connects to an API session over the server's projects, open files included
(NODE_API.md).
Port of Go's language server: tsgo --lsp -stdio (cmd/tsc/lsp.go -> internal/lsp -> internal/project ->
internal/ls). Same rules as the rest of the port (PORTING.md): function-by-function from Go, same names in
snake_case, // file.go:LINE origin markers, Go quirks preserved, no redesign. This guide covers editor setup, the implementation contracts, validation and known gaps.
The initial port log records the completed phases and their measurements.
Go package (ts-ref/tsc/internal/…) |
Rust crate / module | notes |
|---|---|---|
lsp/lsproto (+ jsonrpc) |
tsrs_lsproto |
lsp_generated.rs is generated by tools/gen-lsproto (a port of tools/scripts/lsp/generate.mts that emits Rust) from the same LSP meta model (vscode-languageclient 10.1.1, meta model 3.18.0); jsonrpc.rs, baseproto.rs (Content-Length framing), lsp.rs, util.rs by hand |
lsp |
tsrs_lsp |
server.rs (read / dispatch / write loops, handler table), logger.rs, dynamic_queue.rs, progress.rs, lspwatcher.rs (builtin in-process watcher) |
fswatch |
tsrs_fswatch |
FSEvents (CoreServices through extern "C", unsafe confined to fsevents_darwin_ffi.rs) and kqueue on macOS, inotify on Linux (libc); fanotify_linux.go and windows.go not ported (notes/lsp-robust.md) |
project (+ background) |
tsrs_project |
session, snapshots, overlays, project collection builder, config file registry, parse cache, checker pool, auto-import registry host and cache warming; ata is out of scope for now |
project/dirty, project/logging |
tsrs_projectutil (re-exported as tsrs_project::{dirty, logging}) |
leaf packages that ls/autoimport imports too |
ls (+ lsconv, lsutil, change, autoimport) |
tsrs_ls (tsrs_ls::lsconv, ::lsutil, ::change, ::autoimport, …) |
one Rust file per Go file, same base names |
astnav, format, sourcemap |
tsrs_astnav and tsrs_sourcemap (crates of their own, re-exported as tsrs_ls::astnav / ::sourcemap), tsrs_ls::format |
tsrs_astnav is also used by the checker and the API, tsrs_sourcemap by emit; format is used by the language service and by the API's formatNodeForInsertion (tsrs_api/src/printing.rs) |
fourslash (+ the tests in fourslash/tests) |
upstream Go, tools/go-fourslash, tasks/fourslash_server |
unchanged Go assertions driving Rust LSP subprocesses |
checker/services.go, checker/exports.go |
tsrs_checker (services.rs, exports.rs) |
the checker API the language service calls |
compiler (program reuse, pluggable checker pool) |
tsrs_compiler |
UpdateProgram / ReuseProgram, ProgramOptions.CreateCheckerPool, the CheckerPool interface |
cmd/tsc/lsp.go |
tsrs_cli (lsp.rs) |
tsrs --lsp -stdio |
The Go fourslash subprocess runner keeps the upstream Go test bodies and assertions and drives the Rust language server over a local LSP socket. It uses a test-only server entry point, a filesystem bridge, and a read-only project-state bridge. Go content-mapper callbacks cannot cross the process boundary, so the server serves the Rust port of the same in-process test mappers to the tests that set one. The Go runner runs in Linux CI with zero failures and a floor of 4,149 exercised groups, including all 4,066 groups that passed in the former translated Rust suite. Release verification and PGO/BOLT training also use the Go runner.
Go generates lsp_generated.go from the LSP meta model with generate.mts; tsrs generates lsp_generated.rs the same
way (tools/gen-lsproto/generate.mts, run with node; the meta model JSON is committed next to it so generation is
reproducible offline). Mapping, chosen so that the ls and lsp code ports mechanically:
- structures -> structs, fields snake_case; Go
*Toptional field ->Option<T>(Boxonly where the type is recursive),[]T/[]*T->Vec<T>,map[K]V->OrderedMap/FxHashMapas Go's iteration order requires. - enumerations -> newtypes over the base type with associated consts named like the rest of the port
(
lsproto.SymbolKindFile->SymbolKind::FILE), because LSP enums are open sets (Go accepts any value). - unions (
IntegerOrString,LocationOrLocationsOrDefinitionLinksOrNull, …) -> structs ofOptions with Go's field names, exactly like Go, soif x.Integer != nilports asif let Some(i) = &x.integer. - JSON goes through
tsrs_core::json::Value(already Go-compatible: key order preserved, Go's number and string encoding). No serde. Every generated type implementstsrs_lsproto::Json(to_json/from_json), generated with the same required / optional / omitzero rules as Go's struct codec (structcodec.go), including Go's errors for missing required fields. - No JSON-RPC or LSP framework crate: Go's transport is ~400 lines (
baseproto.go,jsonrpc.go) and is ported.
Go runs the server as goroutines: a read loop, a dispatch loop and a write loop connected by queues; synchronous
handlers (document sync, initialized, configuration) run on the dispatch loop and change the session; language
service requests take a snapshot synchronously and run their work in a fresh goroutine. tsrs keeps the same
structure with OS threads:
- read thread:
Server::read_loop(frames,initialize, responses to server->client requests,$/cancelRequest); - dispatch thread:
Server::dispatch_loop, runshandle_request_or_notification; - write thread:
Server::write_loop; - async request work runs on worker threads with 512 MB stacks (the checker recurses as deeply as in the CLI). As
with Go's goroutine per request, a job never waits for a thread: when every worker is busy (often blocked on a
checker), another one starts.
max(4, available_parallelism)workers stay and wait for jobs; one beyond that exits when it finds no job, handing back its thread arena and slab (tsrs_core::ptrReleaseAtExit), so the thread count follows the requests in flight (notes/lsp-server.md has the numbers). As with Go'sGOMAXPROCS, at mostavailable_parallelismof them run at once (tsrs_core::runslots); a job gives its slot back while it waits for a checker, a client response, another thread forcing a lazy list, a context timeout or background tasks. - session-level background work (Go's
background.Queue, scheduled diagnostics refreshes, snapshot updates on timers) runs on a separate fixed pool of 6 background threads with 512 MB stacks (tsrs_project::background); Go'stime.AfterFunc-> one timer thread with a deadline heap that dispatches the callbacks onto those workers.
Shared data obeys the existing threading contract (PORTING.md "Threading"): source files are parsed and bound by one
thread and then read-only; programs are immutable after construction (Go's Program is too); a checker is used by
one thread at a time (the pool hands it out under a lock, Go's heldBy), and everything it allocates is
checker-owned. Snapshots are immutable and shared as Arc<Snapshot>; Go's explicit ref / Deref counts are kept
(they drive parse-cache releases), the Arc only keeps the memory alive.
The checker pool is Go's project/checkerpool.go (one diagnostics checker + N-1 query checkers per program, request
and file affinity, idle disposal after 30 s), behind the tsrs_compiler::CheckerPool trait that Go's
compiler.CheckerPool interface becomes; Program gets ProgramOptions::create_checker_pool as in Go. The CLI
keeps its own pool. ls.LanguageService borrows a checker exactly like Go (program.GetTypeCheckerForFile(ctx, file) returns the checker and a release function -> a guard object that releases on drop).
Nested checker acquisition: Go's call hierarchy (and a few other ls paths) acquires a second
checker while holding one. The project pool (what the server uses) hands out a different query checker, as in Go.
The compiler's built-in pool (CLI, compiler-level tests) locks each checker, where Go's non-exclusive getter returns
it unlocked and aliases it; a nested acquisition on the same checker would deadlock there. Accepted: no language
service path runs on the built-in pool; aliasing a &mut Checker is not expressible soundly in Rust.
Cancellation ($/cancelRequest): as in Go, the read loop cancels the request's Context; the checker polls it at
Go's points (checkSourceElements, deferred nodes, contextual deprecations, the unused checks; c.ctx is set by
checkSourceFile and cleared when it returns) and records wasCanceled; a canceled checker panics on reuse
(checkNotCanceled), so the project pool disposes it on release (query, diagnostics and API checkers); the ls
functions and the handler registrations check ctx.Err() where Go does, and the dispatch loop answers
RequestCancelled. Polling a live context is one atomic load; the CLI's background context has no cancel node.
File watching: with a client that supports dynamic registration of workspace/didChangeWatchedFiles, the session
registers glob watchers with the client and the client's notifications invalidate programs. Without it, where the
default fswatch backend is fast-recursive (FSEvents on macOS; Windows in Go), the server runs the builtin
lspwatcher (Go's choice in handleInitialized): one fswatch subscription per registered glob, ancestor watches
for directories that do not exist yet, synthetic creates on promotion, 75 ms batching, then
Session.DidChangeWatchedFiles like a client notification. Elsewhere (Linux) watching is disabled, as in Go.
The server rebuilds programs after edits and uses regions to release old versions once nothing refers to them. Each region owns its arena allocations and releases them together. The ownership rules below replace Go's GC for server data; see the memory design and lifetime corrections.
| object | Go lifetime | tsrs lifetime |
|---|---|---|
| a parsed file version (text, AST, symbols, flow nodes, and its lazily filled data) | until neither the parse cache nor a live program refers to it | file region: the parse cache's parse function runs parse + bind in a fresh region; the cache entry owns it until its final Deref, and so does every program owner whose program contains the file |
| types, signatures, links, transient symbols, synthetic nodes of a program's checkers | until nothing refers to the checker or its data | checker region per pooled checker: the holder's allocation target while it is created and while it is held; a disposed checker (idle timeout, cancellation) is freed once the requests that held it are done, or with the pool when its data may outlive them (see below) |
Program (file lists, maps, resolution data; cloned per edit by ReuseProgram) |
GC | program owner (tsrs_project memregions.rs), held by every Project value that refers to the program; what CreateProgram allocates is in the version's region, the full build's region is shared by its clones (they share its processed-file data); dropping the owner frees the checkers, the Program (tsrs_compiler::free_program) and the regions |
| auto-import registry update scratch (module and alias resolvers, extraction checkers, resolution caches) | GC | scratch region per Registry::clone_registry, freed before it returns; files the update acquired are released at the end of the snapshot clone as in Go (and freed when nothing else holds them) |
| auto-import registry versions (buckets, indexes, entrypoints: heap; directories' package.json entries: arena) | GC | heap values by Rust ownership; the package.json entries an update reads for directories go to a package.json region of that update, held by every registry version whose directories still refer into it (Registry::regions) |
| package.json cache entries of a program's resolution data (copied to its clones) | GC | the original cache's region when added while that region is the allocation target (the full build); otherwise the thread arena (arena::enter_table_owner) |
| symlinked directories and files the project-reference dts-faking host learns (the host is shared by every version cloned from a full build) | GC | the thread arena (arena::enter_table_owner; the host's table is on the heap): a module specifier lookup can add one while a checker or a later version's region is the target |
| request-scoped results (lsproto values, strings) | GC | ordinary Rust ownership |
Mechanism (tsrs_core::arena): Region::enter makes a region the thread's allocation target until the returned
scope is dropped (scopes nest; with_arena reads one thread-local pointer, as before). A region is an Arena of its
own, so its free lists and checkpoints are its own (a recycling site frees into the arena that allocated the block;
debug builds assert it). It keeps a drop list of the values allocated in it whose type needs drop, and freeing it
runs those drops, so heap memory owned by links and tables goes too. Lazily filled data of a shared object is routed
to the object's own region (arena::enter_owner(addr): SourceFile's JSDoc cache, line and position maps, name
table, identifier set, token cache, declaration map; a command line's rootDir errors; the program's symlink cache
goes to the full build's region); process-wide statics allocate in the thread arena (arena::enter_thread_arena).
Entries of a table that later versions share or copy and any thread may fill (the resolution data's package.json
cache, the dts-faking host's symlinks) use arena::enter_table_owner: the current target if the table lives in it,
else the thread arena, without waiting for a region another thread has entered (parse workers fill the cache while
the building thread holds the full build's region). Regions bump upwards and their chunks are carved from per-thread
slabs, and a file region is trimmed after binding: tens of thousands of file regions would otherwise each cost a
partly used page.
Two ownership constraints matter when changing this code:
- A program is not freed when Go's refcount drops it (snapshot dispose ->
ParseCache.Deref): a request that got a language service from an older snapshot holds no snapshot reference in Go either and relies on the GC. The owner is therefore tied to Rust ownership of theProjectvalues (snapshots and language services hold them), and file regions are owned by program owners as well as by the cache entry. - A disposed checker (idle timeout, cancellation) is freed with its region once no request that held it can still
use its data: Go's language service keeps using results after releasing the checker (diagnostics are converted
after
GetSemanticDiagnosticsreturned), so the dispatch loop gives every message a lease (tsrs_project::checkerDataLease, in the request context and, while the handler runs, the thread's), each acquisition registers it with the checker, and the free waits for the checker's last lease to end. A checker held without a lease (outside the server's dispatch loop; the API checker, whose handles outlive requests) is pinned, and a checker whose data was stored in a pool- or program-lifetime structure is marked escaped (arena::note_escape: the pool's accumulated global diagnostics, the program's declaration diagnostics cache, the include processor's diagnostics); both are parked until the pool is freed. Holding a checker keeps the program owner alive.
Run the arena recycling checks after changes to region ownership.
The memory notes record edit and completion measurements on xstate, including registry updates. The server has also been run on a large private monorepo.
tools/oracle/lsp: drivestsgo-ref --lsp -stdioandtsrs --lsp -stdiowith the same scripted session (initialize, open, edits, requests), answers server->client requests identically, dropswindow/logMessageand timing-dependent notifications, and diffs the JSON responses (andpublishDiagnosticsper URI and version).- Conformance stays byte-identical (
tsrs-test run --suite all, both lazy modes): the LSP work does not change checker semantics; any checker change made for the language service API is additive. - Go Fourslash drives the production server implementation in separate Rust processes; its results and skips are below.
The initial port log includes the oracle results for diagnostics, navigation and watched-file
invalidation. lsp_oracle.mjs --closed GLOB --disk-edits N [--disk-edit-at REGEX] [--watch-client] tests a closed
file changing on disk through client notifications or the builtin watcher; fixtures are in
tools/oracle/lsp/fixtures.
The tsrs_ls::autoimport registry builds buckets sequentially where Go fans out to
goroutines (discovery, extraction, bucket building; same results, the extraction checker pool holds one checker).
autoimport.ProjectID (a Go fmt.Stringer interface) is a string newtype. Go shares one *checker.Checker between
a request, its autoimport.View and the import adder built on the view; the view keeps the checker's address
(View::checker, one unsafe with a SAFETY comment), because callers keep using the checker while the view is
alive. The registry's clone host is only valid during Registry::clone_registry; the module resolvers, alias
resolvers and checkers built from it live in the update's scratch region, freed before it returns. The
extraction checker's compareSymbols is not a total order (files outside the alias resolver's root files map to
index 0, as in Go), so sort_symbols uses Go's pdqsort port there (checker::Program::source_files_complete).
The recorded beta validation passes 4,092 groups, with 0 failures and 470 skips
through the Go subprocess runner.
Its state snapshots preserve the upstream project-state assertions. Go's @tsc setup helper builds fixtures for
eight groups unsupported by the former translated harness; their LSP requests run against Rust. See the
runner guide
for commands and comparison results.
Run the suite with .github/scripts/go-fourslash-gate.sh after building
cargo build --profile dev -p tsrs_fourslash_server. To select cases, use
node tools/go-fourslash/run.mjs -- -run '^TestQuickInfoAlias$' -v.
The generated Rust suite and its translator have been removed. CI, PGO training, and BOLT release gates use the Go harness against the appropriate Rust task binary. The port log retains the translated runner's historical results and verify-family breakdown.
- A pending API session with no connected client is stopped by an explicit LSP
shutdown, but EOF or context cancellation alone leaves its listener pending and its private Unix socket directory behind. This matcheshandleInitializeAPISessionandcloseAPISessionsin the pinned Go source (3e9236361fa9). - Automatic type acquisition, performance/project telemetry, profiling requests and localized messages are not ported. Request-failure telemetry, including flaky diagnostics, is sent when enabled.
- Eight
@tscfixture groups use Go'stsctests.GetFileMapWithBuildbefore the Rust LSP session starts; this verifies Rust LSP behavior with the resulting files, not Rust emit or build. - Builtin watcher backends for Windows and Linux fanotify are not ported. Linux uses inotify, Go's fallback; the server enables builtin watching only with a fast-recursive backend, so Linux needs client watch support.
Checked in the code on 2026-10-10; collected from the porting waves' notes.
- Go maps the language service iterates (change tracker
changes, code-fixfixIdSeen, import adderaddToExisting/newImports, renamechanges) areOrderedMaps (insertion order) here, so the output order is fixed where Go's can vary. - Unicode classes outside ASCII: Go's
unicode.IsLower/IsUpper/IsDigit(categories Ll / Lu / Nd) are approximated by Rust'schar::is_lowercase/is_uppercase(the Lowercase / Uppercase properties) andis_numeric(Nd, Nl, No). They differ for a few modifier letters, circled letters and non-decimal digits (autoimport/util.rsgo_unicode_is_lower,symbols.rsgo_is_upper,completions_3.rsunicode_is_digit). typeToStringForDiagtruncation (codeactions_fixmissingtypeannotation.rs) replaces each byte of a cut multi-byte character with U+FFFD, as Go's byte slice does once the description is serialized.- The class-implements-interface fix creates a missing-member fixer per member where Go keeps one; the fixer has no state of its own, so creations and insertions happen in Go's order.
- Document symbols:
mergeExpandos/mergeChildrenmutate symbols that several parents' child lists share; the port keeps the sharing with anRc<RefCell<…>>tree (DocSym, symbols.rs). No test has a child shared by two expando targets, so that path is not verified against Go. - Code lens resolve after a recovered panic returns an empty
CodeLenswhere Go returns nil (the Rust response type is not nullable); the request was already answered with the recover's error. - Cross-project orchestration (
handle_cross_project, references / rename across projects) searches projects sequentially; Go fans out to goroutines. Results are merged in the same order, so responses are identical; only latency differs on multi-project workspaces. - An edit that keeps a file's imports reuses the program even when the file has synthetic imports; Go rebuilds it.
- The
thisparameter that a JSDoc@thistag adds has a name without a source position (Go position -1). Go's name table stores -1 for it, which reads as "appears more than once"; tsrs stores the same. Go to definition and source definition onthispoint at the tag name (definition.rs,get_file_and_start_pos_from_declaration) where Go converts -1 to the start of the file. - A line that ends in U+2028 / U+2029 ends before the line break (
get_line_end_of_position, completions_2.rs). Go subtracts one byte, which ends the line inside the break's three-byte encoding: a#region/#endregionline's folding range then ends two characters later and its collapsed text ends in two U+FFFD, and a/**followed by the break gets JSDoc tag completions instead of the JSDoc template that\ngets. - With the UTF-8 position encoding, a character offset inside a multi-byte character snaps back to the start of that
character (
line_and_character_to_position), as a UTF-16 offset inside a surrogate pair does. Go keeps the byte offset: an edit there splits the character and leaves invalid UTF-8 in the overlay, which Rust text cannot hold. Byte offsets that skip the converter snap the same way (lsconv::snap_to_char_boundary):data.positionincompletionItem/resolve, and the API'sgetCompletionsAtPosition, whose UTF-16 offset between the halves of a surrogate pair maps inside the character. Go slices its strings at those bytes; Rust panicked there. - Signature help in JSX attributes: Go builds the attributes' argument span with the length as its end
(
core.NewTextRange(attributeSpanStart, attributeSpanEnd-attributeSpanStart), ls/signaturehelp.go:1002), so the span rarely contains the position and Go walks on to an enclosing call. tsrs computes the real span (signaturehelp.rsget_immediately_containing_argument_info). Inside a JSX element that is itself in a call's argument (wrap(() => <Comp href={…} />)), tsrs shows the element's signature (none for an intrinsic element) where Go shows the enclosing call's; outside a call both show the element's signature. - A
file:URI whose percent-escapes decode to invalid UTF-8 (latin%FF1.ts) names a file with U+FFFD in place of each bad sequence (DocumentUri::file_name, lsp.rsunescape); Go keeps the raw bytes. Responses for such an open document (definition, references, rename) then namelatin%EF%BF%BD1.ts, a document the client never opened, where Go answers withlatin%FF1.ts; and two open URIs that differ only in such bytes (%FFand%FE) share one overlay. Rust file names cannot hold the bytes; keeping the escape text would collide with a real file namedlatin%FF1.ts(URIlatin%25FF1.ts), and mapping the bytes to other characters with a file that contains those characters, so only remembering each open document's URI would fix it. Go's handling is not lossless either: the file name in completion item data reaches the client with U+FFFD (JSON encoding), so itscompletionItem/resolveon that document fails with "no project found". On disk neither reads such a file: Go's and tsrs's directory reads both yield the U+FFFD name, and a file matched byincludeis reported as not found (TS6053).
{ "js/ts.experimental.useTsgo": true, "js/ts.tsdk.path": "./node_modules/tsrs/tsdk", "js/ts.trace.server": "verbose" // optional: protocol log in the "TypeScript 7" output channel }