Watch files over LSP (#806)

Co-authored-by: Jake Bailey <[email protected]>

Author: andrewbranch

internal/api/api.go

@@ -119,6 +119,16 @@ func (api *API) PositionEncoding() lsproto.PositionEncodingKind {
 	return lsproto.PositionEncodingKindUTF8
 }
 
+// Client implements ProjectHost.
+func (api *API) Client() project.Client {
+	return nil
+}
+
+// IsWatchEnabled implements ProjectHost.
+func (api *API) IsWatchEnabled() bool {
+	return false
+}
+
 func (api *API) HandleRequest(id int, method string, payload []byte) ([]byte, error) {
 	params, err := unmarshalPayload(method, payload)
 	if err != nil {
@@ -351,7 +361,7 @@ func (api *API) getOrCreateScriptInfo(fileName string, path tspath.Path, scriptK
 	if !ok {
 		return nil
 	}
-	info = project.NewScriptInfo(fileName, path, scriptKind)
+	info = project.NewScriptInfo(fileName, path, scriptKind, api.host.FS())
 	info.SetTextFromDisk(content)
 	api.scriptInfosMu.Lock()
 	defer api.scriptInfosMu.Unlock()

internal/compiler/fileloader.go

@@ -38,6 +38,7 @@ type fileLoader struct {
 
 type processedFiles struct {
 	files                         []*ast.SourceFile
+	missingFiles                  []string
 	resolvedModules               map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]
 	sourceFileMetaDatas           map[tspath.Path]*ast.SourceFileMetaData
 	jsxRuntimeImportSpecifiers    map[tspath.Path]*jsxRuntimeImportSpecifier
@@ -85,6 +86,7 @@ func processAllProgramFiles(
 	totalFileCount := int(loader.totalFileCount.Load())
 	libFileCount := int(loader.libFileCount.Load())
 
+	var missingFiles []string
 	files := make([]*ast.SourceFile, 0, totalFileCount-libFileCount)
 	libFiles := make([]*ast.SourceFile, 0, totalFileCount) // totalFileCount here since we append files to it later to construct the final list
 
@@ -95,6 +97,10 @@ func processAllProgramFiles(
 
 	for task := range loader.collectTasks(loader.rootTasks) {
 		file := task.file
+		if file == nil {
+			missingFiles = append(missingFiles, task.normalizedFilePath)
+			continue
+		}
 		if task.isLib {
 			libFiles = append(libFiles, file)
 		} else {
@@ -190,10 +196,8 @@ func (p *fileLoader) collectTasksWorker(tasks []*parseTask, seen core.Set[*parse
 			}
 		}
 
-		if task.file != nil {
-			if !yield(task) {
-				return false
-			}
+		if !yield(task) {
+			return false
 		}
 	}
 	return true
@@ -245,6 +249,10 @@ func (t *parseTask) start(loader *fileLoader) {
 
 	loader.wg.Queue(func() {
 		file := loader.parseSourceFile(t.normalizedFilePath)
+		if file == nil {
+			return
+		}
+
 		t.file = file
 		loader.wg.Queue(func() {
 			t.metadata = loader.loadSourceFileMetaData(file.Path())

internal/lsp/lsproto/jsonrpc.go

@@ -28,6 +28,10 @@ type ID struct {
 	int int32
 }
 
+func NewIDString(str string) *ID {
+	return &ID{str: str}
+}
+
 func (id *ID) MarshalJSON() ([]byte, error) {
 	if id.str != "" {
 		return json.Marshal(id.str)
@@ -43,6 +47,13 @@ func (id *ID) UnmarshalJSON(data []byte) error {
 	return json.Unmarshal(data, &id.int)
 }
 
+func (id *ID) TryInt() (int32, bool) {
+	if id == nil || id.str != "" {
+		return 0, false
+	}
+	return id.int, true
+}
+
 func (id *ID) MustInt() int32 {
 	if id.str != "" {
 		panic("ID is not an integer")
@@ -54,11 +65,19 @@ func (id *ID) MustInt() int32 {
 
 type RequestMessage struct {
 	JSONRPC JSONRPCVersion `json:"jsonrpc"`
-	ID      *ID            `json:"id"`
+	ID      *ID            `json:"id,omitempty"`
 	Method  Method         `json:"method"`
 	Params  any            `json:"params"`
 }
 
+func NewRequestMessage(method Method, id *ID, params any) *RequestMessage {
+	return &RequestMessage{
+		ID:     id,
+		Method: method,
+		Params: params,
+	}
+}
+
 func (r *RequestMessage) UnmarshalJSON(data []byte) error {
 	var raw struct {
 		JSONRPC JSONRPCVersion  `json:"jsonrpc"`

internal/lsp/server.go

@@ -43,14 +43,18 @@ func NewServer(opts *ServerOptions) *Server {
 	}
 }
 
-var _ project.ServiceHost = (*Server)(nil)
+var (
+	_ project.ServiceHost = (*Server)(nil)
+	_ project.Client      = (*Server)(nil)
+)
 
 type Server struct {
 	r *lsproto.BaseReader
 	w *lsproto.BaseWriter
 
 	stderr io.Writer
 
+	clientSeq     int32
 	requestMethod string
 	requestTime   time.Time
 
@@ -62,36 +66,100 @@ type Server struct {
 	initializeParams *lsproto.InitializeParams
 	positionEncoding lsproto.PositionEncodingKind
 
+	watchEnabled   bool
+	watcherID      int
+	watchers       core.Set[project.WatcherHandle]
 	logger         *project.Logger
 	projectService *project.Service
 	converters     *ls.Converters
 }
 
-// FS implements project.ProjectServiceHost.
+// FS implements project.ServiceHost.
 func (s *Server) FS() vfs.FS {
 	return s.fs
 }
 
-// DefaultLibraryPath implements project.ProjectServiceHost.
+// DefaultLibraryPath implements project.ServiceHost.
 func (s *Server) DefaultLibraryPath() string {
 	return s.defaultLibraryPath
 }
 
-// GetCurrentDirectory implements project.ProjectServiceHost.
+// GetCurrentDirectory implements project.ServiceHost.
 func (s *Server) GetCurrentDirectory() string {
 	return s.cwd
 }
 
-// NewLine implements project.ProjectServiceHost.
+// NewLine implements project.ServiceHost.
 func (s *Server) NewLine() string {
 	return s.newLine.GetNewLineCharacter()
 }
 
-// Trace implements project.ProjectServiceHost.
+// Trace implements project.ServiceHost.
 func (s *Server) Trace(msg string) {
 	s.Log(msg)
 }
 
+// Client implements project.ServiceHost.
+func (s *Server) Client() project.Client {
+	if !s.watchEnabled {
+		return nil
+	}
+	return s
+}
+
+// WatchFiles implements project.Client.
+func (s *Server) WatchFiles(watchers []*lsproto.FileSystemWatcher) (project.WatcherHandle, error) {
+	watcherId := fmt.Sprintf("watcher-%d", s.watcherID)
+	if err := s.sendRequest(lsproto.MethodClientRegisterCapability, &lsproto.RegistrationParams{
+		Registrations: []*lsproto.Registration{
+			{
+				Id:     watcherId,
+				Method: string(lsproto.MethodWorkspaceDidChangeWatchedFiles),
+				RegisterOptions: ptrTo(any(lsproto.DidChangeWatchedFilesRegistrationOptions{
+					Watchers: watchers,
+				})),
+			},
+		},
+	}); err != nil {
+		return "", fmt.Errorf("failed to register file watcher: %w", err)
+	}
+
+	handle := project.WatcherHandle(watcherId)
+	s.watchers.Add(handle)
+	s.watcherID++
+	return handle, nil
+}
+
+// UnwatchFiles implements project.Client.
+func (s *Server) UnwatchFiles(handle project.WatcherHandle) error {
+	if s.watchers.Has(handle) {
+		if err := s.sendRequest(lsproto.MethodClientUnregisterCapability, &lsproto.UnregistrationParams{
+			Unregisterations: []*lsproto.Unregistration{
+				{
+					Id:     string(handle),
+					Method: string(lsproto.MethodWorkspaceDidChangeWatchedFiles),
+				},
+			},
+		}); err != nil {
+			return fmt.Errorf("failed to unregister file watcher: %w", err)
+		}
+		s.watchers.Delete(handle)
+		return nil
+	}
+
+	return fmt.Errorf("no file watcher exists with ID %s", handle)
+}
+
+// RefreshDiagnostics implements project.Client.
+func (s *Server) RefreshDiagnostics() error {
+	if ptrIsTrue(s.initializeParams.Capabilities.Workspace.Diagnostics.RefreshSupport) {
+		if err := s.sendRequest(lsproto.MethodWorkspaceDiagnosticRefresh, nil); err != nil {
+			return fmt.Errorf("failed to refresh diagnostics: %w", err)
+		}
+	}
+	return nil
+}
+
 func (s *Server) Run() error {
 	for {
 		req, err := s.read()
@@ -105,6 +173,11 @@ func (s *Server) Run() error {
 			return err
 		}
 
+		// TODO: handle response messages
+		if req == nil {
+			continue
+		}
+
 		if s.initializeParams == nil {
 			if req.Method == lsproto.MethodInitialize {
 				if err := s.handleInitialize(req); err != nil {
@@ -132,12 +205,37 @@ func (s *Server) read() (*lsproto.RequestMessage, error) {
 
 	req := &lsproto.RequestMessage{}
 	if err := json.Unmarshal(data, req); err != nil {
+		res := &lsproto.ResponseMessage{}
+		if err = json.Unmarshal(data, res); err == nil {
+			// !!! TODO: handle response
+			return nil, nil
+		}
 		return nil, fmt.Errorf("%w: %w", lsproto.ErrInvalidRequest, err)
 	}
 
 	return req, nil
 }
 
+func (s *Server) sendRequest(method lsproto.Method, params any) error {
+	s.clientSeq++
+	id := lsproto.NewIDString(fmt.Sprintf("ts%d", s.clientSeq))
+	req := lsproto.NewRequestMessage(method, id, params)
+	data, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+	return s.w.Write(data)
+}
+
+func (s *Server) sendNotification(method lsproto.Method, params any) error {
+	req := lsproto.NewRequestMessage(method, nil /*id*/, params)
+	data, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+	return s.w.Write(data)
+}
+
 func (s *Server) sendResult(id *lsproto.ID, result any) error {
 	return s.sendResponse(&lsproto.ResponseMessage{
 		ID:     id,
@@ -189,6 +287,8 @@ func (s *Server) handleMessage(req *lsproto.RequestMessage) error {
 		return s.handleDidSave(req)
 	case *lsproto.DidCloseTextDocumentParams:
 		return s.handleDidClose(req)
+	case *lsproto.DidChangeWatchedFilesParams:
+		return s.handleDidChangeWatchedFiles(req)
 	case *lsproto.DocumentDiagnosticParams:
 		return s.handleDocumentDiagnostic(req)
 	case *lsproto.HoverParams:
@@ -262,9 +362,14 @@ func (s *Server) handleInitialize(req *lsproto.RequestMessage) error {
 }
 
 func (s *Server) handleInitialized(req *lsproto.RequestMessage) error {
+	if s.initializeParams.Capabilities.Workspace.DidChangeWatchedFiles != nil && *s.initializeParams.Capabilities.Workspace.DidChangeWatchedFiles.DynamicRegistration {
+		s.watchEnabled = true
+	}
+
 	s.logger = project.NewLogger([]io.Writer{s.stderr}, "" /*file*/, project.LogLevelVerbose)
 	s.projectService = project.NewService(s, project.ServiceOptions{
 		Logger:           s.logger,
+		WatchEnabled:     s.watchEnabled,
 		PositionEncoding: s.positionEncoding,
 	})
 
@@ -322,6 +427,11 @@ func (s *Server) handleDidClose(req *lsproto.RequestMessage) error {
 	return nil
 }
 
+func (s *Server) handleDidChangeWatchedFiles(req *lsproto.RequestMessage) error {
+	params := req.Params.(*lsproto.DidChangeWatchedFilesParams)
+	return s.projectService.OnWatchedFilesChanged(params.Changes)
+}
+
 func (s *Server) handleDocumentDiagnostic(req *lsproto.RequestMessage) error {
 	params := req.Params.(*lsproto.DocumentDiagnosticParams)
 	file, project := s.getFileAndProject(params.TextDocument.Uri)
@@ -445,3 +555,10 @@ func codeFence(lang string, code string) string {
 func ptrTo[T any](v T) *T {
 	return &v
 }
+
+func ptrIsTrue(v *bool) bool {
+	if v == nil {
+		return false
+	}
+	return *v
+}

internal/project/documentregistry.go

@@ -92,9 +92,9 @@ func (r *DocumentRegistry) getDocumentWorker(
 	if entry, ok := r.documents.Load(key); ok {
 		// We have an entry for this file. However, it may be for a different version of
 		// the script snapshot. If so, update it appropriately.
-		if entry.sourceFile.Version != scriptInfo.version {
+		if entry.sourceFile.Version != scriptInfo.Version() {
 			sourceFile := parser.ParseSourceFile(scriptInfo.fileName, scriptInfo.path, scriptInfo.text, scriptTarget, scanner.JSDocParsingModeParseAll)
-			sourceFile.Version = scriptInfo.version
+			sourceFile.Version = scriptInfo.Version()
 			entry.mu.Lock()
 			defer entry.mu.Unlock()
 			entry.sourceFile = sourceFile
@@ -104,7 +104,7 @@ func (r *DocumentRegistry) getDocumentWorker(
 	} else {
 		// Have never seen this file with these settings. Create a new source file for it.
 		sourceFile := parser.ParseSourceFile(scriptInfo.fileName, scriptInfo.path, scriptInfo.text, scriptTarget, scanner.JSDocParsingModeParseAll)
-		sourceFile.Version = scriptInfo.version
+		sourceFile.Version = scriptInfo.Version()
 		entry, _ := r.documents.LoadOrStore(key, &registryEntry{
 			sourceFile: sourceFile,
 			refCount:   0,

internal/project/host.go

@@ -1,10 +1,23 @@
 package project
 
-import "github.com/microsoft/typescript-go/internal/vfs"
+import (
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/vfs"
+)
+
+type WatcherHandle string
+
+type Client interface {
+	WatchFiles(watchers []*lsproto.FileSystemWatcher) (WatcherHandle, error)
+	UnwatchFiles(handle WatcherHandle) error
+	RefreshDiagnostics() error
+}
 
 type ServiceHost interface {
 	FS() vfs.FS
 	DefaultLibraryPath() string
 	GetCurrentDirectory() string
 	NewLine() string
+
+	Client() Client
 }

internal/project/project.go

@@ -2,6 +2,8 @@ package project
 
 import (
 	"fmt"
+	"maps"
+	"slices"
 	"strings"
 	"sync"
 
@@ -17,6 +19,7 @@ import (
 )
 
 //go:generate go tool golang.org/x/tools/cmd/stringer -type=Kind -output=project_stringer_generated.go
+const hr = "-----------------------------------------------"
 
 var projectNamer = &namer{}
 
@@ -31,6 +34,14 @@ const (
 	KindAuxiliary
 )
 
+type PendingReload int
+
+const (
+	PendingReloadNone PendingReload = iota
+	PendingReloadFileNames
+	PendingReloadFull
+)
+
 type ProjectHost interface {
 	tsoptions.ParseConfigHost
 	NewLine() string
@@ -41,6 +52,9 @@ type ProjectHost interface {
 	OnDiscoveredSymlink(info *ScriptInfo)
 	Log(s string)
 	PositionEncoding() lsproto.PositionEncodingKind
+
+	IsWatchEnabled() bool
+	Client() Client
 }
 
 type Project struct {
@@ -56,27 +70,38 @@ type Project struct {
 	hasAddedOrRemovedFiles    bool
 	hasAddedOrRemovedSymlinks bool
 	deferredClose             bool
-	reloadConfig              bool
+	pendingReload             PendingReload
 
-	currentDirectory string
+	comparePathsOptions tspath.ComparePathsOptions
+	currentDirectory    string
 	// Inferred projects only
 	rootPath tspath.Path
 
 	configFileName string
 	configFilePath tspath.Path
 	// rootFileNames was a map from Path to { NormalizedPath, ScriptInfo? } in the original code.
 	// But the ProjectService owns script infos, so it's not clear why there was an extra pointer.
-	rootFileNames   *collections.OrderedMap[tspath.Path, string]
-	compilerOptions *core.CompilerOptions
-	languageService *ls.LanguageService
-	program         *compiler.Program
+	rootFileNames     *collections.OrderedMap[tspath.Path, string]
+	compilerOptions   *core.CompilerOptions
+	parsedCommandLine *tsoptions.ParsedCommandLine
+	languageService   *ls.LanguageService
+	program           *compiler.Program
+
+	// Watchers
+	rootFilesWatch          *watchedFiles[[]string]
+	failedLookupsWatch      *watchedFiles[map[tspath.Path]string]
+	affectingLocationsWatch *watchedFiles[map[tspath.Path]string]
 }
 
 func NewConfiguredProject(configFileName string, configFilePath tspath.Path, host ProjectHost) *Project {
 	project := NewProject(configFileName, KindConfigured, tspath.GetDirectoryPath(configFileName), host)
 	project.configFileName = configFileName
 	project.configFilePath = configFilePath
 	project.initialLoadPending = true
+	client := host.Client()
+	if host.IsWatchEnabled() && client != nil {
+		project.rootFilesWatch = newWatchedFiles(client, lsproto.WatchKindChange|lsproto.WatchKindCreate|lsproto.WatchKindDelete, core.Identity)
+	}
 	return project
 }
 
@@ -96,6 +121,19 @@ func NewProject(name string, kind Kind, currentDirectory string, host ProjectHos
 		currentDirectory: currentDirectory,
 		rootFileNames:    &collections.OrderedMap[tspath.Path, string]{},
 	}
+	project.comparePathsOptions = tspath.ComparePathsOptions{
+		CurrentDirectory:          currentDirectory,
+		UseCaseSensitiveFileNames: host.FS().UseCaseSensitiveFileNames(),
+	}
+	client := host.Client()
+	if host.IsWatchEnabled() && client != nil {
+		project.failedLookupsWatch = newWatchedFiles(client, lsproto.WatchKindCreate, func(data map[tspath.Path]string) []string {
+			return slices.Sorted(maps.Values(data))
+		})
+		project.affectingLocationsWatch = newWatchedFiles(client, lsproto.WatchKindChange|lsproto.WatchKindCreate|lsproto.WatchKindDelete, func(data map[tspath.Path]string) []string {
+			return slices.Sorted(maps.Values(data))
+		})
+	}
 	project.languageService = ls.NewLanguageService(project)
 	project.markAsDirty()
 	return project
@@ -128,13 +166,7 @@ func (p *Project) GetProjectVersion() int {
 
 // GetRootFileNames implements LanguageServiceHost.
 func (p *Project) GetRootFileNames() []string {
-	fileNames := make([]string, 0, p.rootFileNames.Size())
-	for path, fileName := range p.rootFileNames.Entries() {
-		if p.host.GetScriptInfoByPath(path) != nil {
-			fileNames = append(fileNames, fileName)
-		}
-	}
-	return fileNames
+	return slices.Collect(p.rootFileNames.Values())
 }
 
 // GetSourceFile implements LanguageServiceHost.
@@ -205,6 +237,98 @@ func (p *Project) LanguageService() *ls.LanguageService {
 	return p.languageService
 }
 
+func (p *Project) getRootFileWatchGlobs() []string {
+	if p.kind == KindConfigured {
+		globs := p.parsedCommandLine.WildcardDirectories()
+		result := make([]string, 0, len(globs)+1)
+		result = append(result, p.configFileName)
+		for dir, recursive := range globs {
+			result = append(result, fmt.Sprintf("%s/%s", dir, core.IfElse(recursive, recursiveFileGlobPattern, fileGlobPattern)))
+		}
+		for _, fileName := range p.parsedCommandLine.LiteralFileNames() {
+			result = append(result, fileName)
+		}
+		return result
+	}
+	return nil
+}
+
+func (p *Project) getModuleResolutionWatchGlobs() (failedLookups map[tspath.Path]string, affectingLocaions map[tspath.Path]string) {
+	failedLookups = make(map[tspath.Path]string)
+	affectingLocaions = make(map[tspath.Path]string)
+	for _, resolvedModulesInFile := range p.program.GetResolvedModules() {
+		for _, resolvedModule := range resolvedModulesInFile {
+			for _, failedLookupLocation := range resolvedModule.FailedLookupLocations {
+				path := p.toPath(failedLookupLocation)
+				if _, ok := failedLookups[path]; !ok {
+					failedLookups[path] = failedLookupLocation
+				}
+			}
+			for _, affectingLocation := range resolvedModule.AffectingLocations {
+				path := p.toPath(affectingLocation)
+				if _, ok := affectingLocaions[path]; !ok {
+					affectingLocaions[path] = affectingLocation
+				}
+			}
+		}
+	}
+	return failedLookups, affectingLocaions
+}
+
+func (p *Project) updateWatchers() {
+	client := p.host.Client()
+	if !p.host.IsWatchEnabled() || client == nil {
+		return
+	}
+
+	rootFileGlobs := p.getRootFileWatchGlobs()
+	failedLookupGlobs, affectingLocationGlobs := p.getModuleResolutionWatchGlobs()
+
+	if rootFileGlobs != nil {
+		if updated, err := p.rootFilesWatch.update(rootFileGlobs); err != nil {
+			p.log(fmt.Sprintf("Failed to update root file watch: %v", err))
+		} else if updated {
+			p.log("Root file watches updated:\n" + formatFileList(rootFileGlobs, "\t", hr))
+		}
+	}
+
+	if updated, err := p.failedLookupsWatch.update(failedLookupGlobs); err != nil {
+		p.log(fmt.Sprintf("Failed to update failed lookup watch: %v", err))
+	} else if updated {
+		p.log("Failed lookup watches updated:\n" + formatFileList(p.failedLookupsWatch.globs, "\t", hr))
+	}
+
+	if updated, err := p.affectingLocationsWatch.update(affectingLocationGlobs); err != nil {
+		p.log(fmt.Sprintf("Failed to update affecting location watch: %v", err))
+	} else if updated {
+		p.log("Affecting location watches updated:\n" + formatFileList(p.affectingLocationsWatch.globs, "\t", hr))
+	}
+}
+
+// onWatchEventForNilScriptInfo is fired for watch events that are not the
+// project tsconfig, and do not have a ScriptInfo for the associated file.
+// This could be a case of one of the following:
+//   - A file is being created that will be added to the project.
+//   - An affecting location was changed.
+//   - A file is being created that matches a watch glob, but is not actually
+//     part of the project, e.g., a .js file in a project without --allowJs.
+func (p *Project) onWatchEventForNilScriptInfo(fileName string) {
+	path := p.toPath(fileName)
+	if p.kind == KindConfigured {
+		if p.rootFileNames.Has(path) || p.parsedCommandLine.MatchesFileName(fileName) {
+			p.pendingReload = PendingReloadFileNames
+			p.markAsDirty()
+			return
+		}
+	}
+
+	if _, ok := p.failedLookupsWatch.data[path]; ok {
+		p.markAsDirty()
+	} else if _, ok := p.affectingLocationsWatch.data[path]; ok {
+		p.markAsDirty()
+	}
+}
+
 func (p *Project) getOrCreateScriptInfoAndAttachToProject(fileName string, scriptKind core.ScriptKind) *ScriptInfo {
 	if scriptInfo := p.host.GetOrCreateScriptInfoForFile(fileName, p.toPath(fileName), scriptKind); scriptInfo != nil {
 		scriptInfo.attachToProject(p)
@@ -232,6 +356,7 @@ func (p *Project) markAsDirty() {
 	}
 }
 
+// updateIfDirty returns true if the project was updated.
 func (p *Project) updateIfDirty() bool {
 	// !!! p.invalidateResolutionsOfFailedLookupLocations()
 	return p.dirty && p.updateGraph()
@@ -257,11 +382,17 @@ func (p *Project) updateGraph() bool {
 	hasAddedOrRemovedFiles := p.hasAddedOrRemovedFiles
 	p.initialLoadPending = false
 
-	if p.kind == KindConfigured && p.reloadConfig {
-		if err := p.LoadConfig(); err != nil {
-			panic(fmt.Sprintf("failed to reload config: %v", err))
+	if p.kind == KindConfigured && p.pendingReload != PendingReloadNone {
+		switch p.pendingReload {
+		case PendingReloadFileNames:
+			p.parsedCommandLine = tsoptions.ReloadFileNamesOfParsedCommandLine(p.parsedCommandLine, p.host.FS())
+			p.setRootFiles(p.parsedCommandLine.FileNames())
+		case PendingReloadFull:
+			if err := p.LoadConfig(); err != nil {
+				panic(fmt.Sprintf("failed to reload config: %v", err))
+			}
 		}
-		p.reloadConfig = false
+		p.pendingReload = PendingReloadNone
 	}
 
 	p.hasAddedOrRemovedFiles = false
@@ -283,6 +414,7 @@ func (p *Project) updateGraph() bool {
 		}
 	}
 
+	p.updateWatchers()
 	return true
 }
 
@@ -324,7 +456,7 @@ func (p *Project) removeFile(info *ScriptInfo, fileExists bool, detachFromProjec
 		case KindInferred:
 			p.rootFileNames.Delete(info.path)
 		case KindConfigured:
-			p.reloadConfig = true
+			p.pendingReload = PendingReloadFileNames
 		}
 	}
 
@@ -384,6 +516,7 @@ func (p *Project) LoadConfig() error {
 			}, "    ", "  ")),
 		)
 
+		p.parsedCommandLine = parsedCommandLine
 		p.compilerOptions = parsedCommandLine.CompilerOptions()
 		p.setRootFiles(parsedCommandLine.FileNames())
 	} else {
@@ -399,16 +532,21 @@ func (p *Project) setRootFiles(rootFileNames []string) {
 	newRootScriptInfos := make(map[tspath.Path]struct{}, len(rootFileNames))
 	for _, file := range rootFileNames {
 		scriptKind := p.getScriptKind(file)
-		scriptInfo := p.host.GetOrCreateScriptInfoForFile(file, p.toPath(file), scriptKind)
-		newRootScriptInfos[scriptInfo.path] = struct{}{}
-		if _, isRoot := p.rootFileNames.Get(scriptInfo.path); !isRoot {
+		path := p.toPath(file)
+		// !!! updateNonInferredProjectFiles uses a fileExists check, which I guess
+		// could be needed if a watcher fails?
+		scriptInfo := p.host.GetOrCreateScriptInfoForFile(file, path, scriptKind)
+		newRootScriptInfos[path] = struct{}{}
+		isAlreadyRoot := p.rootFileNames.Has(path)
+
+		if !isAlreadyRoot && scriptInfo != nil {
 			p.addRoot(scriptInfo)
 			if scriptInfo.isOpen {
 				// !!!
 				// s.removeRootOfInferredProjectIfNowPartOfOtherProject(scriptInfo)
 			}
-		} else {
-			p.rootFileNames.Set(scriptInfo.path, file)
+		} else if !isAlreadyRoot {
+			p.rootFileNames.Set(path, file)
 		}
 	}
 
@@ -451,7 +589,7 @@ func (p *Project) print(writeFileNames bool, writeFileExplanation bool, writeFil
 			// if writeFileExplanation {}
 		}
 	}
-	builder.WriteString("-----------------------------------------------")
+	builder.WriteString(hr)
 	return builder.String()
 }
 
@@ -466,3 +604,19 @@ func (p *Project) logf(format string, args ...interface{}) {
 func (p *Project) Close() {
 	// !!!
 }
+
+func formatFileList(files []string, linePrefix string, groupSuffix string) string {
+	var builder strings.Builder
+	length := len(groupSuffix)
+	for _, file := range files {
+		length += len(file) + len(linePrefix) + 1
+	}
+	builder.Grow(length)
+	for _, file := range files {
+		builder.WriteString(linePrefix)
+		builder.WriteString(file)
+		builder.WriteRune('\n')
+	}
+	builder.WriteString(groupSuffix)
+	return builder.String()
+}

internal/project/scriptinfo.go

@@ -27,9 +27,11 @@ type ScriptInfo struct {
 	deferredDelete        bool
 
 	containingProjects []*Project
+
+	fs vfs.FS
 }
 
-func NewScriptInfo(fileName string, path tspath.Path, scriptKind core.ScriptKind) *ScriptInfo {
+func NewScriptInfo(fileName string, path tspath.Path, scriptKind core.ScriptKind, fs vfs.FS) *ScriptInfo {
 	isDynamic := isDynamicFileName(fileName)
 	realpath := core.IfElse(isDynamic, path, "")
 	return &ScriptInfo{
@@ -38,6 +40,7 @@ func NewScriptInfo(fileName string, path tspath.Path, scriptKind core.ScriptKind
 		realpath:   realpath,
 		isDynamic:  isDynamic,
 		scriptKind: scriptKind,
+		fs:         fs,
 	}
 }
 
@@ -51,15 +54,29 @@ func (s *ScriptInfo) Path() tspath.Path {
 
 func (s *ScriptInfo) LineMap() *ls.LineMap {
 	if s.lineMap == nil {
-		s.lineMap = ls.ComputeLineStarts(s.text)
+		s.lineMap = ls.ComputeLineStarts(s.Text())
 	}
 	return s.lineMap
 }
 
 func (s *ScriptInfo) Text() string {
+	s.reloadIfNeeded()
 	return s.text
 }
 
+func (s *ScriptInfo) Version() int {
+	s.reloadIfNeeded()
+	return s.version
+}
+
+func (s *ScriptInfo) reloadIfNeeded() {
+	if s.pendingReloadFromDisk {
+		if newText, ok := s.fs.ReadFile(s.fileName); ok {
+			s.SetTextFromDisk(newText)
+		}
+	}
+}
+
 func (s *ScriptInfo) open(newText string) {
 	s.isOpen = true
 	s.pendingReloadFromDisk = false
@@ -133,7 +150,7 @@ func (s *ScriptInfo) isOrphan() bool {
 }
 
 func (s *ScriptInfo) editContent(change ls.TextChange) {
-	s.setText(change.ApplyTo(s.text))
+	s.setText(change.ApplyTo(s.Text()))
 	s.markContainingProjectsAsDirty()
 }
 

internal/project/service.go

@@ -30,6 +30,7 @@ type assignProjectResult struct {
 type ServiceOptions struct {
 	Logger           *Logger
 	PositionEncoding lsproto.PositionEncodingKind
+	WatchEnabled     bool
 }
 
 var _ ProjectHost = (*Service)(nil)
@@ -38,6 +39,7 @@ type Service struct {
 	host                ServiceHost
 	options             ServiceOptions
 	comparePathsOptions tspath.ComparePathsOptions
+	converters          *ls.Converters
 
 	configuredProjects map[tspath.Path]*Project
 	// unrootedInferredProject is the inferred project for files opened without a projectRootDirectory
@@ -61,7 +63,7 @@ type Service struct {
 func NewService(host ServiceHost, options ServiceOptions) *Service {
 	options.Logger.Info(fmt.Sprintf("currentDirectory:: %s useCaseSensitiveFileNames:: %t", host.GetCurrentDirectory(), host.FS().UseCaseSensitiveFileNames()))
 	options.Logger.Info("libs Location:: " + host.DefaultLibraryPath())
-	return &Service{
+	service := &Service{
 		host:    host,
 		options: options,
 		comparePathsOptions: tspath.ComparePathsOptions{
@@ -82,6 +84,12 @@ func NewService(host ServiceHost, options ServiceOptions) *Service {
 		filenameToScriptInfoVersion: make(map[tspath.Path]int),
 		realpathToScriptInfos:       make(map[tspath.Path]map[*ScriptInfo]struct{}),
 	}
+
+	service.converters = ls.NewConverters(options.PositionEncoding, func(fileName string) ls.ScriptInfo {
+		return service.GetScriptInfo(fileName)
+	})
+
+	return service
 }
 
 // GetCurrentDirectory implements ProjectHost.
@@ -124,6 +132,16 @@ func (s *Service) PositionEncoding() lsproto.PositionEncodingKind {
 	return s.options.PositionEncoding
 }
 
+// Client implements ProjectHost.
+func (s *Service) Client() Client {
+	return s.host.Client()
+}
+
+// IsWatchEnabled implements ProjectHost.
+func (s *Service) IsWatchEnabled() bool {
+	return s.options.WatchEnabled
+}
+
 func (s *Service) Projects() []*Project {
 	projects := make([]*Project, 0, len(s.configuredProjects)+len(s.inferredProjects))
 	for _, project := range s.configuredProjects {
@@ -215,6 +233,62 @@ func (s *Service) SourceFileCount() int {
 	return s.documentRegistry.size()
 }
 
+func (s *Service) OnWatchedFilesChanged(changes []*lsproto.FileEvent) error {
+	for _, change := range changes {
+		fileName := ls.DocumentURIToFileName(change.Uri)
+		path := s.toPath(fileName)
+		if project, ok := s.configuredProjects[path]; ok {
+			// tsconfig of project
+			if err := s.onConfigFileChanged(project, change.Type); err != nil {
+				return fmt.Errorf("error handling config file change: %w", err)
+			}
+		} else if _, ok := s.openFiles[path]; ok {
+			// open file
+			continue
+		} else if info := s.GetScriptInfoByPath(path); info != nil {
+			// closed existing file
+			if change.Type == lsproto.FileChangeTypeDeleted {
+				s.handleDeletedFile(info, true /*deferredDelete*/)
+			} else {
+				info.deferredDelete = false
+				info.delayReloadNonMixedContentFile()
+				// !!! s.delayUpdateProjectGraphs(info.containingProjects, false /*clearSourceMapperCache*/)
+				// !!! s.handleSourceMapProjects(info)
+			}
+		} else {
+			for _, project := range s.configuredProjects {
+				project.onWatchEventForNilScriptInfo(fileName)
+			}
+		}
+	}
+
+	client := s.host.Client()
+	if client != nil {
+		return client.RefreshDiagnostics()
+	}
+
+	return nil
+}
+
+func (s *Service) onConfigFileChanged(project *Project, changeKind lsproto.FileChangeType) error {
+	wasDeferredClose := project.deferredClose
+	switch changeKind {
+	case lsproto.FileChangeTypeCreated:
+		if wasDeferredClose {
+			project.deferredClose = false
+		}
+	case lsproto.FileChangeTypeDeleted:
+		project.deferredClose = true
+	}
+
+	s.delayUpdateProjectGraph(project)
+	if !project.deferredClose {
+		project.pendingReload = PendingReloadFull
+		project.markAsDirty()
+	}
+	return nil
+}
+
 func (s *Service) ensureProjectStructureUpToDate() {
 	var hasChanges bool
 	for _, project := range s.configuredProjects {
@@ -351,7 +425,7 @@ func (s *Service) getOrCreateScriptInfoWorker(fileName string, path tspath.Path,
 			}
 		}
 
-		info = NewScriptInfo(fileName, path, scriptKind)
+		info = NewScriptInfo(fileName, path, scriptKind, s.host.FS())
 		if fromDisk {
 			info.SetTextFromDisk(fileContent)
 		}

internal/project/service_test.go

@@ -0,0 +1,61 @@
+package project
+
+import (
+	"slices"
+
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+)
+
+const (
+	fileGlobPattern          = "*.{js,jsx,mjs,cjs,ts,tsx,mts,cts,json}"
+	recursiveFileGlobPattern = "**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts,json}"
+)
+
+type watchedFiles[T any] struct {
+	client    Client
+	getGlobs  func(data T) []string
+	watchKind lsproto.WatchKind
+
+	data      T
+	globs     []string
+	watcherID WatcherHandle
+}
+
+func newWatchedFiles[T any](client Client, watchKind lsproto.WatchKind, getGlobs func(data T) []string) *watchedFiles[T] {
+	return &watchedFiles[T]{
+		client:    client,
+		watchKind: watchKind,
+		getGlobs:  getGlobs,
+	}
+}
+
+func (w *watchedFiles[T]) update(newData T) (updated bool, err error) {
+	newGlobs := w.getGlobs(newData)
+	w.data = newData
+	if slices.Equal(w.globs, newGlobs) {
+		return false, nil
+	}
+
+	w.globs = newGlobs
+	if w.watcherID != "" {
+		if err = w.client.UnwatchFiles(w.watcherID); err != nil {
+			return false, err
+		}
+	}
+
+	watchers := make([]*lsproto.FileSystemWatcher, 0, len(newGlobs))
+	for _, glob := range newGlobs {
+		watchers = append(watchers, &lsproto.FileSystemWatcher{
+			GlobPattern: lsproto.PatternOrRelativePattern{
+				Pattern: &glob,
+			},
+			Kind: &w.watchKind,
+		})
+	}
+	watcherID, err := w.client.WatchFiles(watchers)
+	if err != nil {
+		return false, err
+	}
+	w.watcherID = watcherID
+	return true, nil
+}

internal/project/watch.go

@@ -122,7 +122,7 @@ func makeUnitsFromTest(code string, fileName string) testCaseContent {
 	for _, data := range testUnits {
 		allFiles[tspath.GetNormalizedAbsolutePath(data.name, currentDirectory)] = data.content
 	}
-	parseConfigHost := tsoptionstest.NewVFSParseConfigHost(allFiles, currentDirectory)
+	parseConfigHost := tsoptionstest.NewVFSParseConfigHost(allFiles, currentDirectory, true /*useCaseSensitiveFileNames*/)
 
 	// check if project has tsconfig.json in the list of files
 	var tsConfig *tsoptions.ParsedCommandLine

internal/testrunner/test_case_parser.go

@@ -12,12 +12,15 @@ import (
 	"github.com/microsoft/typescript-go/internal/vfs/vfstest"
 )
 
+//go:generate go tool github.com/matryer/moq -stub -fmt goimports -pkg projecttestutil -out clientmock_generated.go ../../project Client
+
 type ProjectServiceHost struct {
 	fs                 vfs.FS
 	mu                 sync.Mutex
 	defaultLibraryPath string
 	output             strings.Builder
 	logger             *project.Logger
+	ClientMock         *ClientMock
 }
 
 // DefaultLibraryPath implements project.ProjectServiceHost.
@@ -47,6 +50,11 @@ func (p *ProjectServiceHost) NewLine() string {
 	return "\n"
 }
 
+// Client implements project.ProjectServiceHost.
+func (p *ProjectServiceHost) Client() project.Client {
+	return p.ClientMock
+}
+
 func (p *ProjectServiceHost) ReplaceFS(files map[string]string) {
 	p.fs = bundled.WrapFS(vfstest.FromMap(files, false /*useCaseSensitiveFileNames*/))
 }
@@ -56,7 +64,8 @@ var _ project.ServiceHost = (*ProjectServiceHost)(nil)
 func Setup(files map[string]string) (*project.Service, *ProjectServiceHost) {
 	host := newProjectServiceHost(files)
 	service := project.NewService(host, project.ServiceOptions{
-		Logger: host.logger,
+		Logger:       host.logger,
+		WatchEnabled: true,
 	})
 	return service, host
 }
@@ -66,6 +75,7 @@ func newProjectServiceHost(files map[string]string) *ProjectServiceHost {
 	host := &ProjectServiceHost{
 		fs:                 fs,
 		defaultLibraryPath: bundled.LibPath(),
+		ClientMock:         &ClientMock{},
 	}
 	host.logger = project.NewLogger([]io.Writer{&host.output}, "", project.LogLevelVerbose)
 	return host

internal/testutil/projecttestutil/clientmock_generated.go

@@ -9,6 +9,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/diagnostics"
 	"github.com/microsoft/typescript-go/internal/stringutil"
+	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
 )
 
@@ -58,6 +59,11 @@ func ParseCommandLine(
 		Errors:        parser.errors,
 		Raw:           parser.options, // !!! keep optionsBase incase needed later. todo: figure out if this is still needed
 		CompileOnSave: nil,
+
+		comparePathsOptions: tspath.ComparePathsOptions{
+			UseCaseSensitiveFileNames: host.FS().UseCaseSensitiveFileNames(),
+			CurrentDirectory:          host.GetCurrentDirectory(),
+		},
 	}
 }
 

internal/testutil/projecttestutil/projecttestutil.go

@@ -2,20 +2,52 @@ package tsoptions
 
 import (
 	"slices"
+	"sync"
 
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/tspath"
+	"github.com/microsoft/typescript-go/internal/vfs"
 )
 
 type ParsedCommandLine struct {
 	ParsedConfig *core.ParsedOptions `json:"parsedConfig"`
 
-	ConfigFile *TsConfigSourceFile `json:"configFile"` // TsConfigSourceFile, used in Program and ExecuteCommandLine
-	Errors     []*ast.Diagnostic   `json:"errors"`
-	Raw        any                 `json:"raw"`
-	// WildcardDirectories map[string]watchDirectoryFlags
-	CompileOnSave *bool `json:"compileOnSave"`
+	ConfigFile    *TsConfigSourceFile `json:"configFile"` // TsConfigSourceFile, used in Program and ExecuteCommandLine
+	Errors        []*ast.Diagnostic   `json:"errors"`
+	Raw           any                 `json:"raw"`
+	CompileOnSave *bool               `json:"compileOnSave"`
 	// TypeAquisition *core.TypeAcquisition
+
+	comparePathsOptions     tspath.ComparePathsOptions
+	wildcardDirectoriesOnce sync.Once
+	wildcardDirectories     map[string]bool
+	extraFileExtensions     []fileExtensionInfo
+}
+
+// WildcardDirectories returns the cached wildcard directories, initializing them if needed
+func (p *ParsedCommandLine) WildcardDirectories() map[string]bool {
+	if p.wildcardDirectories != nil {
+		return p.wildcardDirectories
+	}
+
+	p.wildcardDirectoriesOnce.Do(func() {
+		p.wildcardDirectories = getWildcardDirectories(
+			p.ConfigFile.configFileSpecs.validatedIncludeSpecs,
+			p.ConfigFile.configFileSpecs.validatedExcludeSpecs,
+			p.comparePathsOptions,
+		)
+	})
+
+	return p.wildcardDirectories
+}
+
+// Normalized file names explicitly specified in `files`
+func (p *ParsedCommandLine) LiteralFileNames() []string {
+	if p.ConfigFile != nil {
+		return p.FileNames()[0:len(p.ConfigFile.configFileSpecs.validatedFilesSpec)]
+	}
+	return nil
 }
 
 func (p *ParsedCommandLine) SetParsedOptions(o *core.ParsedOptions) {
@@ -30,6 +62,7 @@ func (p *ParsedCommandLine) CompilerOptions() *core.CompilerOptions {
 	return p.ParsedConfig.CompilerOptions
 }
 
+// All file names matched by files, include, and exclude patterns
 func (p *ParsedCommandLine) FileNames() []string {
 	return p.ParsedConfig.FileNames
 }
@@ -45,3 +78,69 @@ func (p *ParsedCommandLine) GetConfigFileParsingDiagnostics() []*ast.Diagnostic
 	}
 	return p.Errors
 }
+
+// Porting reference: ProjectService.isMatchedByConfig
+func (p *ParsedCommandLine) MatchesFileName(fileName string) bool {
+	path := tspath.ToPath(fileName, p.comparePathsOptions.CurrentDirectory, p.comparePathsOptions.UseCaseSensitiveFileNames)
+	if slices.ContainsFunc(p.FileNames(), func(f string) bool {
+		return path == tspath.ToPath(f, p.comparePathsOptions.CurrentDirectory, p.comparePathsOptions.UseCaseSensitiveFileNames)
+	}) {
+		return true
+	}
+
+	if p.ConfigFile == nil {
+		return false
+	}
+
+	if len(p.ConfigFile.configFileSpecs.validatedIncludeSpecs) == 0 {
+		return false
+	}
+
+	supportedExtensions := GetSupportedExtensionsWithJsonIfResolveJsonModule(
+		p.CompilerOptions(),
+		GetSupportedExtensions(p.CompilerOptions(), p.extraFileExtensions),
+	)
+
+	if !tspath.FileExtensionIsOneOf(fileName, core.Flatten(supportedExtensions)) {
+		return false
+	}
+
+	if p.ConfigFile.configFileSpecs.matchesExclude(fileName, p.comparePathsOptions) {
+		return false
+	}
+
+	var allFileNames core.Set[tspath.Path]
+	for _, fileName := range p.FileNames() {
+		allFileNames.Add(tspath.ToPath(fileName, p.comparePathsOptions.CurrentDirectory, p.comparePathsOptions.UseCaseSensitiveFileNames))
+	}
+
+	if hasFileWithHigherPriorityExtension(string(path), supportedExtensions, func(fileName string) bool {
+		return allFileNames.Has(tspath.Path(fileName))
+	}) {
+		return false
+	}
+
+	return p.ConfigFile.configFileSpecs.matchesInclude(fileName, p.comparePathsOptions)
+}
+
+func ReloadFileNamesOfParsedCommandLine(p *ParsedCommandLine, fs vfs.FS) *ParsedCommandLine {
+	parsedConfig := *p.ParsedConfig
+	parsedConfig.FileNames = getFileNamesFromConfigSpecs(
+		*p.ConfigFile.configFileSpecs,
+		p.comparePathsOptions.CurrentDirectory,
+		p.CompilerOptions(),
+		fs,
+		p.extraFileExtensions,
+	)
+	parsedCommandLine := ParsedCommandLine{
+		ParsedConfig:        &parsedConfig,
+		ConfigFile:          p.ConfigFile,
+		Errors:              p.Errors,
+		Raw:                 p.Raw,
+		CompileOnSave:       p.CompileOnSave,
+		comparePathsOptions: p.comparePathsOptions,
+		wildcardDirectories: p.wildcardDirectories,
+		extraFileExtensions: p.extraFileExtensions,
+	}
+	return &parsedCommandLine
+}

internal/tsoptions/commandlineparser.go

@@ -0,0 +1,369 @@
+package tsoptions_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/tsoptions"
+	"github.com/microsoft/typescript-go/internal/tsoptions/tsoptionstest"
+	"github.com/microsoft/typescript-go/internal/vfs/vfstest"
+	"gotest.tools/v3/assert"
+)
+
+func TestParsedCommandLine(t *testing.T) {
+	t.Parallel()
+	t.Run("MatchesFileName", func(t *testing.T) {
+		t.Parallel()
+
+		noFiles := map[string]string{}
+		noFilesFS := vfstest.FromMap(noFiles, true)
+
+		files := map[string]string{
+			"/dev/a.ts":         "",
+			"/dev/a.d.ts":       "",
+			"/dev/a.js":         "",
+			"/dev/b.ts":         "",
+			"/dev/b.js":         "",
+			"/dev/c.d.ts":       "",
+			"/dev/z/a.ts":       "",
+			"/dev/z/abz.ts":     "",
+			"/dev/z/aba.ts":     "",
+			"/dev/z/b.ts":       "",
+			"/dev/z/bbz.ts":     "",
+			"/dev/z/bba.ts":     "",
+			"/dev/x/a.ts":       "",
+			"/dev/x/aa.ts":      "",
+			"/dev/x/b.ts":       "",
+			"/dev/x/y/a.ts":     "",
+			"/dev/x/y/b.ts":     "",
+			"/dev/js/a.js":      "",
+			"/dev/js/b.js":      "",
+			"/dev/js/d.min.js":  "",
+			"/dev/js/ab.min.js": "",
+			"/ext/ext.ts":       "",
+			"/ext/b/a..b.ts":    "",
+		}
+
+		assertMatches := func(t *testing.T, parsedCommandLine *tsoptions.ParsedCommandLine, files map[string]string, matches []string) {
+			t.Helper()
+			for fileName := range files {
+				actual := parsedCommandLine.MatchesFileName(fileName)
+				expected := slices.Contains(matches, fileName)
+				assert.Equal(t, actual, expected, "fileName: %s", fileName)
+			}
+			for _, fileName := range matches {
+				if _, ok := files[fileName]; !ok {
+					actual := parsedCommandLine.MatchesFileName(fileName)
+					assert.Equal(t, actual, true, "fileName: %s", fileName)
+				}
+			}
+		}
+
+		t.Run("with literal file list", func(t *testing.T) {
+			t.Parallel()
+			t.Run("without exclude", func(t *testing.T) {
+				t.Parallel()
+				parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+					t,
+					`{
+						"files": [
+							"a.ts",
+							"b.ts"
+						]
+					}`,
+					files,
+					"/dev",
+					/*useCaseSensitiveFileNames*/ true,
+				)
+
+				assertMatches(t, parsedCommandLine, files, []string{
+					"/dev/a.ts",
+					"/dev/b.ts",
+				})
+			})
+
+			t.Run("are not removed due to excludes", func(t *testing.T) {
+				t.Parallel()
+				parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+					t,
+					`{
+						"files": [
+							"a.ts",
+							"b.ts"
+						],
+						"exclude": [
+							"b.ts"
+						]
+					}`,
+					files,
+					"/dev",
+					/*useCaseSensitiveFileNames*/ true,
+				)
+
+				assertMatches(t, parsedCommandLine, files, []string{
+					"/dev/a.ts",
+					"/dev/b.ts",
+				})
+
+				emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+				assertMatches(t, emptyParsedCommandLine, noFiles, []string{
+					"/dev/a.ts",
+					"/dev/b.ts",
+				})
+			})
+		})
+
+		t.Run("with literal include list", func(t *testing.T) {
+			t.Parallel()
+			t.Run("without exclude", func(t *testing.T) {
+				t.Parallel()
+				parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+					t,
+					`{
+						"include": [
+							"a.ts",
+							"b.ts"
+						]
+					}`,
+					files,
+					"/dev",
+					/*useCaseSensitiveFileNames*/ true,
+				)
+
+				assertMatches(t, parsedCommandLine, files, []string{
+					"/dev/a.ts",
+					"/dev/b.ts",
+				})
+
+				emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+				assertMatches(t, emptyParsedCommandLine, noFiles, []string{
+					"/dev/a.ts",
+					"/dev/b.ts",
+				})
+			})
+
+			t.Run("with non .ts file extensions", func(t *testing.T) {
+				t.Parallel()
+				parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+					t,
+					`{
+						"include": [
+							"a.js",
+							"b.js"
+						]
+					}`,
+					files,
+					"/dev",
+					/*useCaseSensitiveFileNames*/ true,
+				)
+
+				assertMatches(t, parsedCommandLine, files, []string{})
+
+				emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+				assertMatches(t, emptyParsedCommandLine, noFiles, []string{})
+			})
+
+			t.Run("with literal excludes", func(t *testing.T) {
+				t.Parallel()
+				parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+					t,
+					`{
+						"include": [
+							"a.ts",
+							"b.ts"
+						],
+						"exclude": [
+							"b.ts"
+						]
+					}`,
+					files,
+					"/dev",
+					/*useCaseSensitiveFileNames*/ true,
+				)
+
+				assertMatches(t, parsedCommandLine, files, []string{
+					"/dev/a.ts",
+				})
+
+				emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+				assertMatches(t, emptyParsedCommandLine, noFiles, []string{
+					"/dev/a.ts",
+				})
+			})
+
+			t.Run("with wildcard excludes", func(t *testing.T) {
+				t.Parallel()
+				parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+					t,
+					`{
+						"include": [
+							"a.ts",
+							"b.ts",
+							"z/a.ts",
+							"z/abz.ts",
+							"z/aba.ts",
+							"x/b.ts"
+						],
+						"exclude": [
+							"*.ts",
+							"z/??z.ts",
+							"*/b.ts"
+						]
+					}`,
+					files,
+					"/dev",
+					/*useCaseSensitiveFileNames*/ true,
+				)
+
+				assertMatches(t, parsedCommandLine, files, []string{
+					"/dev/z/a.ts",
+					"/dev/z/aba.ts",
+				})
+
+				emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+				assertMatches(t, emptyParsedCommandLine, noFiles, []string{
+					"/dev/z/a.ts",
+					"/dev/z/aba.ts",
+				})
+			})
+
+			t.Run("with wildcard include list", func(t *testing.T) {
+				t.Parallel()
+
+				t.Run("star matches only ts files", func(t *testing.T) {
+					t.Parallel()
+					parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+						t,
+						`{
+							"include": [
+								"*"
+							]
+						}`,
+						files,
+						"/dev",
+						/*useCaseSensitiveFileNames*/ true,
+					)
+
+					assertMatches(t, parsedCommandLine, files, []string{
+						"/dev/a.ts",
+						"/dev/b.ts",
+						"/dev/c.d.ts",
+					})
+
+					// a.d.ts matches if a.ts is not already included
+					emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+					assertMatches(t, emptyParsedCommandLine, noFiles, []string{
+						"/dev/a.ts",
+						"/dev/a.d.ts",
+						"/dev/b.ts",
+						"/dev/c.d.ts",
+					})
+				})
+
+				t.Run("question matches only a single character", func(t *testing.T) {
+					t.Parallel()
+					parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+						t,
+						`{
+							"include": [
+								"x/?.ts"
+							]
+						}`,
+						files,
+						"/dev",
+						/*useCaseSensitiveFileNames*/ true,
+					)
+
+					assertMatches(t, parsedCommandLine, files, []string{
+						"/dev/x/a.ts",
+						"/dev/x/b.ts",
+					})
+
+					emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+					assertMatches(t, emptyParsedCommandLine, noFiles, []string{
+						"/dev/x/a.ts",
+						"/dev/x/b.ts",
+					})
+				})
+
+				t.Run("exclude .js files when allowJs=false", func(t *testing.T) {
+					t.Parallel()
+					parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+						t,
+						`{
+							"include": [
+								"js/*"
+							]
+						}`,
+						files,
+						"/dev",
+						/*useCaseSensitiveFileNames*/ true,
+					)
+
+					assertMatches(t, parsedCommandLine, files, []string{})
+
+					emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+					assertMatches(t, emptyParsedCommandLine, noFiles, []string{})
+				})
+
+				t.Run("include .js files when allowJs=true", func(t *testing.T) {
+					t.Parallel()
+					parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+						t,
+						`{
+							"compilerOptions": {
+								"allowJs": true
+							},
+							"include": [
+								"js/*"
+							]
+						}`,
+						files,
+						"/dev",
+						/*useCaseSensitiveFileNames*/ true,
+					)
+
+					assertMatches(t, parsedCommandLine, files, []string{
+						"/dev/js/a.js",
+						"/dev/js/b.js",
+					})
+
+					emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+					assertMatches(t, emptyParsedCommandLine, noFiles, []string{
+						"/dev/js/a.js",
+						"/dev/js/b.js",
+					})
+				})
+
+				t.Run("include explicitly listed .min.js files when allowJs=true", func(t *testing.T) {
+					t.Parallel()
+					parsedCommandLine := tsoptionstest.GetParsedCommandLine(
+						t,
+						`{
+							"compilerOptions": {
+								"allowJs": true
+							},
+							"include": [
+								"js/*.min.js"
+							]
+						}`,
+						files,
+						"/dev",
+						/*useCaseSensitiveFileNames*/ true,
+					)
+
+					assertMatches(t, parsedCommandLine, files, []string{
+						"/dev/js/d.min.js",
+						"/dev/js/ab.min.js",
+					})
+
+					emptyParsedCommandLine := tsoptions.ReloadFileNamesOfParsedCommandLine(parsedCommandLine, noFilesFS)
+					assertMatches(t, emptyParsedCommandLine, noFiles, []string{
+						"/dev/js/d.min.js",
+						"/dev/js/ab.min.js",
+					})
+				})
+			})
+		})
+	})
+}

internal/tsoptions/parsedcommandline.go

@@ -97,15 +97,51 @@ type configFileSpecs struct {
 	validatedExcludeSpecs []string
 	isDefaultIncludeSpec  bool
 }
+
+func (c *configFileSpecs) matchesExclude(fileName string, comparePathsOptions tspath.ComparePathsOptions) bool {
+	if len(c.validatedExcludeSpecs) == 0 {
+		return false
+	}
+	excludePattern := getRegularExpressionForWildcard(c.validatedExcludeSpecs, comparePathsOptions.CurrentDirectory, "exclude")
+	excludeRegex := getRegexFromPattern(excludePattern, comparePathsOptions.UseCaseSensitiveFileNames)
+	if match, err := excludeRegex.MatchString(fileName); err == nil && match {
+		return true
+	}
+	if !tspath.HasExtension(fileName) {
+		if match, err := excludeRegex.MatchString(tspath.EnsureTrailingDirectorySeparator(fileName)); err == nil && match {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *configFileSpecs) matchesInclude(fileName string, comparePathsOptions tspath.ComparePathsOptions) bool {
+	if len(c.validatedIncludeSpecs) == 0 {
+		return false
+	}
+	for _, spec := range c.validatedIncludeSpecs {
+		includePattern := getPatternFromSpec(spec, comparePathsOptions.CurrentDirectory, "files")
+		if includePattern != "" {
+			includeRegex := getRegexFromPattern(includePattern, comparePathsOptions.UseCaseSensitiveFileNames)
+			if match, err := includeRegex.MatchString(fileName); err == nil && match {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 type fileExtensionInfo struct {
 	extension      string
 	isMixedContent bool
 	scriptKind     core.ScriptKind
 }
+
 type ExtendedConfigCacheEntry struct {
 	extendedResult *TsConfigSourceFile
 	extendedConfig *parsedTsconfig
 }
+
 type parsedTsconfig struct {
 	raw     any
 	options *core.CompilerOptions
@@ -1209,6 +1245,12 @@ func parseJsonConfigFileContentWorker(
 		ConfigFile: sourceFile,
 		Raw:        parsedConfig.raw,
 		Errors:     errors,
+
+		extraFileExtensions: extraFileExtensions,
+		comparePathsOptions: tspath.ComparePathsOptions{
+			UseCaseSensitiveFileNames: host.FS().UseCaseSensitiveFileNames(),
+			CurrentDirectory:          basePathForFileNames,
+		},
 	}
 }
 
@@ -1389,7 +1431,7 @@ func handleOptionConfigDirTemplateSubstitution(compilerOptions *core.CompilerOpt
 
 // hasFileWithHigherPriorityExtension determines whether a literal or wildcard file has already been included that has a higher extension priority.
 // file is the path to the file.
-func hasFileWithHigherPriorityExtension(file string, literalFiles collections.OrderedMap[string, string], wildcardFiles collections.OrderedMap[string, string], extensions [][]string, keyMapper func(value string) string) bool {
+func hasFileWithHigherPriorityExtension(file string, extensions [][]string, hasFile func(fileName string) bool) bool {
 	var extensionGroup []string
 	for _, group := range extensions {
 		if tspath.FileExtensionIsOneOf(file, group) {
@@ -1406,8 +1448,7 @@ func hasFileWithHigherPriorityExtension(file string, literalFiles collections.Or
 		if tspath.FileExtensionIs(file, ext) && (ext != tspath.ExtensionTs || !tspath.FileExtensionIs(file, tspath.ExtensionDts)) {
 			return false
 		}
-		higherPriorityPath := keyMapper(tspath.ChangeExtension(file, ext))
-		if literalFiles.Has(higherPriorityPath) || wildcardFiles.Has(higherPriorityPath) {
+		if hasFile(tspath.ChangeExtension(file, ext)) {
 			if ext == tspath.ExtensionDts && (tspath.FileExtensionIs(file, tspath.ExtensionJs) || tspath.FileExtensionIs(file, tspath.ExtensionJsx)) {
 				// LEGACY BEHAVIOR: An off-by-one bug somewhere in the extension priority system for wildcard module loading allowed declaration
 				// files to be loaded alongside their js(x) counterparts. We regard this as generally undesirable, but retain the behavior to
@@ -1516,7 +1557,10 @@ func getFileNamesFromConfigSpecs(
 			// This handles cases where we may encounter both <file>.ts and
 			// <file>.d.ts (or <file>.js if "allowJs" is enabled) in the same
 			// directory when they are compilation outputs.
-			if hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMappper) {
+			if hasFileWithHigherPriorityExtension(file, supportedExtensions, func(fileName string) bool {
+				canonicalFileName := keyMappper(fileName)
+				return literalFileMap.Has(canonicalFileName) || wildcardFileMap.Has(canonicalFileName)
+			}) {
 				continue
 			}
 			// We may have included a wildcard path with a lower priority

internal/tsoptions/parsedcommandline_test.go

@@ -619,7 +619,7 @@ func baselineParseConfigWith(t *testing.T, baselineFileName string, noSubmoduleB
 			allFileLists[file] = content
 		}
 		allFileLists[configFileName] = config.jsonText
-		host := tsoptionstest.NewVFSParseConfigHost(allFileLists, config.basePath)
+		host := tsoptionstest.NewVFSParseConfigHost(allFileLists, config.basePath, true /*useCaseSensitiveFileNames*/)
 		parsedConfigFileContent := getParsed(config, host, basePath)
 
 		baselineContent.WriteString("Fs::\n")

internal/tsoptions/tsconfigparsing.go

@@ -0,0 +1,14 @@
+package tsoptionstest
+
+import (
+	"github.com/microsoft/typescript-go/internal/tsoptions"
+	"github.com/microsoft/typescript-go/internal/tspath"
+	"gotest.tools/v3/assert"
+)
+
+func GetParsedCommandLine(t assert.TestingT, jsonText string, files map[string]string, currentDirectory string, useCaseSensitiveFileNames bool) *tsoptions.ParsedCommandLine {
+	host := NewVFSParseConfigHost(files, currentDirectory, useCaseSensitiveFileNames)
+	configFileName := tspath.CombinePaths(currentDirectory, "tsconfig.json")
+	tsconfigSourceFile := tsoptions.NewTsconfigSourceFileFromFilePath(configFileName, tspath.ToPath(configFileName, currentDirectory, useCaseSensitiveFileNames), jsonText)
+	return tsoptions.ParseJsonSourceFileConfigFileContent(tsconfigSourceFile, host, currentDirectory, nil, configFileName, nil, nil, nil)
+}

internal/tsoptions/tsconfigparsing_test.go

@@ -33,9 +33,9 @@ func (h *VfsParseConfigHost) GetCurrentDirectory() string {
 	return h.CurrentDirectory
 }
 
-func NewVFSParseConfigHost(files map[string]string, currentDirectory string) *VfsParseConfigHost {
+func NewVFSParseConfigHost(files map[string]string, currentDirectory string, useCaseSensitiveFileNames bool) *VfsParseConfigHost {
 	return &VfsParseConfigHost{
-		Vfs:              vfstest.FromMap(files, true /*useCaseSensitiveFileNames*/),
+		Vfs:              vfstest.FromMap(files, useCaseSensitiveFileNames),
 		CurrentDirectory: currentDirectory,
 	}
 }

internal/tsoptions/tsoptionstest/parsedcommandline.go

@@ -150,6 +150,19 @@ var wildcardMatchers = map[usage]WildcardMatcher{
 	usageExclude:     excludeMatcher,
 }
 
+func getPatternFromSpec(
+	spec string,
+	basePath string,
+	usage usage,
+) string {
+	pattern := getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage])
+	if pattern == "" {
+		return ""
+	}
+	ending := core.IfElse(usage == "exclude", "($|/)", "$")
+	return fmt.Sprintf("^(%s)%s", pattern, ending)
+}
+
 func getSubPatternFromSpec(
 	spec string,
 	basePath string,

internal/tsoptions/tsoptionstest/vfsparseconfighost.go

@@ -0,0 +1,143 @@
+package tsoptions
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/dlclark/regexp2"
+	"github.com/microsoft/typescript-go/internal/tspath"
+)
+
+func getWildcardDirectories(include []string, exclude []string, comparePathsOptions tspath.ComparePathsOptions) map[string]bool {
+	// We watch a directory recursively if it contains a wildcard anywhere in a directory segment
+	// of the pattern:
+	//
+	//  /a/b/**/d   - Watch /a/b recursively to catch changes to any d in any subfolder recursively
+	//  /a/b/*/d    - Watch /a/b recursively to catch any d in any immediate subfolder, even if a new subfolder is added
+	//  /a/b        - Watch /a/b recursively to catch changes to anything in any recursive subfoler
+	//
+	// We watch a directory without recursion if it contains a wildcard in the file segment of
+	// the pattern:
+	//
+	//  /a/b/*      - Watch /a/b directly to catch any new file
+	//  /a/b/a?z    - Watch /a/b directly to catch any new file matching a?z
+
+	if len(include) == 0 {
+		return nil
+	}
+
+	rawExcludeRegex := getRegularExpressionForWildcard(exclude, comparePathsOptions.CurrentDirectory, "exclude")
+	var excludeRegex *regexp.Regexp
+	if rawExcludeRegex != "" {
+		options := ""
+		if !comparePathsOptions.UseCaseSensitiveFileNames {
+			options = "(?i)"
+		}
+		excludeRegex = regexp.MustCompile(options + rawExcludeRegex)
+	}
+
+	wildcardDirectories := make(map[string]bool)
+	wildCardKeyToPath := make(map[string]string)
+
+	var recursiveKeys []string
+
+	for _, file := range include {
+		spec := tspath.NormalizeSlashes(tspath.CombinePaths(comparePathsOptions.CurrentDirectory, file))
+		if excludeRegex != nil && excludeRegex.MatchString(spec) {
+			continue
+		}
+
+		match := getWildcardDirectoryFromSpec(spec, comparePathsOptions.UseCaseSensitiveFileNames)
+		if match != nil {
+			key := match.Key
+			path := match.Path
+			recursive := match.Recursive
+
+			existingPath, existsPath := wildCardKeyToPath[key]
+			var existingRecursive bool
+
+			if existsPath {
+				existingRecursive = wildcardDirectories[existingPath]
+			}
+
+			if !existsPath || (!existingRecursive && recursive) {
+				pathToUse := path
+				if existsPath {
+					pathToUse = existingPath
+				}
+				wildcardDirectories[pathToUse] = recursive
+
+				if !existsPath {
+					wildCardKeyToPath[key] = path
+				}
+
+				if recursive {
+					recursiveKeys = append(recursiveKeys, key)
+				}
+			}
+		}
+
+		// Remove any subpaths under an existing recursively watched directory
+		for path := range wildcardDirectories {
+			for _, recursiveKey := range recursiveKeys {
+				key := toCanonicalKey(path, comparePathsOptions.UseCaseSensitiveFileNames)
+				if key != recursiveKey && tspath.ContainsPath(recursiveKey, key, comparePathsOptions) {
+					delete(wildcardDirectories, path)
+				}
+			}
+		}
+	}
+
+	return wildcardDirectories
+}
+
+func toCanonicalKey(path string, useCaseSensitiveFileNames bool) string {
+	if useCaseSensitiveFileNames {
+		return path
+	}
+	return strings.ToLower(path)
+}
+
+// wildcardDirectoryPattern matches paths with wildcard characters
+var wildcardDirectoryPattern = regexp2.MustCompile(`^[^*?]*(?=\/[^/]*[*?])`, 0)
+
+// wildcardDirectoryMatch represents the result of a wildcard directory match
+type wildcardDirectoryMatch struct {
+	Key       string
+	Path      string
+	Recursive bool
+}
+
+func getWildcardDirectoryFromSpec(spec string, useCaseSensitiveFileNames bool) *wildcardDirectoryMatch {
+	match, _ := wildcardDirectoryPattern.FindStringMatch(spec)
+	if match != nil {
+		// We check this with a few `Index` calls because it's more efficient than complex regex
+		questionWildcardIndex := strings.Index(spec, "?")
+		starWildcardIndex := strings.Index(spec, "*")
+		lastDirectorySeparatorIndex := strings.LastIndexByte(spec, tspath.DirectorySeparator)
+
+		// Determine if this should be watched recursively
+		recursive := (questionWildcardIndex != -1 && questionWildcardIndex < lastDirectorySeparatorIndex) ||
+			(starWildcardIndex != -1 && starWildcardIndex < lastDirectorySeparatorIndex)
+
+		return &wildcardDirectoryMatch{
+			Key:       toCanonicalKey(match.String(), useCaseSensitiveFileNames),
+			Path:      match.String(),
+			Recursive: recursive,
+		}
+	}
+
+	if lastSepIndex := strings.LastIndexByte(spec, tspath.DirectorySeparator); lastSepIndex != -1 {
+		lastSegment := spec[lastSepIndex+1:]
+		if isImplicitGlob(lastSegment) {
+			path := tspath.RemoveTrailingDirectorySeparator(spec)
+			return &wildcardDirectoryMatch{
+				Key:       toCanonicalKey(path, useCaseSensitiveFileNames),
+				Path:      path,
+				Recursive: true,
+			}
+		}
+	}
+
+	return nil
+}