@ttsc/wasm 0.28.4 → 0.28.6

package/dist/.ttsc-wasm-build.json

@@ -1,11 +1,11 @@
 {
   "schema": 1,
-  "identity": "92d9b25262007347543905a8d01c409fafbf97f7fc1277adbcfacdc9c2463fcb",
+  "identity": "5b7306db740afa230fbfe61a2c809466a005338a77e31a76c93f1c5f79b58706",
   "artifacts": [
     {
       "path": "/home/runner/work/ttsc/ttsc/packages/wasm/dist/ttsc.wasm",
       "type": "file",
-      "sha256": "65f224e0973f6cd1c459cd5ba6464e31377427412c5b681bbc67ab5d5e800c74"
+      "sha256": "d3a8605e1c83784bc750712706932ee94e25eccf2d481c82f0605014b27aa09d"
     },
     {
       "path": "/home/runner/work/ttsc/ttsc/packages/wasm/dist/wasm_exec.js",
@@ -147,7 +147,11 @@
         },
         {
           "path": "compiler/incremental.go",
-          "sha256": "3c873bed3659cfe1969a97caea105d230dad510e66d8da6e4ca2c4dc6617a04c"
+          "sha256": "0fc791767af7c9013a555276179b38521df77a750e03b55f1af6cde3393847e4"
+        },
+        {
+          "path": "compiler/resolution.go",
+          "sha256": "8bb3b7e3e16d31286fd16212a9adf100501df1d250ecd0064521b38df01e62e8"
         },
         {
           "path": "compiler/shim.go",
@@ -171,7 +175,7 @@
         },
         {
           "path": "core/shim.go",
-          "sha256": "a3cf692a939eade582138fbafd3e13352d72417830bd5d2db773a97892e6500f"
+          "sha256": "f81ceac2ae56764704b04cd7fbe190213e8d7f9a6d72e9085eb73dd69760e07f"
         },
         {
           "path": "diagnosticwriter/go.mod",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/wasm",
-  "version": "0.28.4",
+  "version": "0.28.6",
   "description": "Build in-browser ttsc playgrounds. Compose ttsc + typescript-go with your own plugins via the Go host helper.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",

package/shim-vendor/shim/compiler/incremental.go

@@ -20,6 +20,7 @@ import (
   innerast "github.com/microsoft/typescript-go/internal/ast"
   "github.com/microsoft/typescript-go/internal/collections"
   innercompiler "github.com/microsoft/typescript-go/internal/compiler"
+  innertsoptions "github.com/microsoft/typescript-go/internal/tsoptions"
   "github.com/microsoft/typescript-go/internal/tspath"
 
   // Imported for EmitFreshWithBuildInfo below, and for the linknamed symbols
@@ -74,18 +75,69 @@ func incrementalFileAffectsGlobalScope(file *innerast.SourceFile) bool
 // The returned strings are tspath.Path values (case-canonicalized on
 // case-insensitive filesystems); map them back to real file names through
 // Program.GetSourceFileByPath when the original spelling matters.
+// Extensionless path references are replaced with the source file Program
+// actually loaded because the upstream incremental helper retains their raw
+// directive path instead of the selected extension-bearing path.
 func GetReferencedFilePaths(program *Program, file *innerast.SourceFile) []string {
   set := incrementalGetReferencedFiles(program, file)
   if set == nil {
     return nil
   }
+  resolvedPathReferences := make(map[tspath.Path]tspath.Path, len(file.ReferencedFiles))
+  sourceDirectory := tspath.GetDirectoryPath(file.FileName())
+  for _, reference := range file.ReferencedFiles {
+    referencedFile := reference.FileName
+    if redirect := program.GetParseFileRedirect(referencedFile); redirect != "" {
+      referencedFile = redirect
+    }
+    rawPath := tspath.ToPath(referencedFile, sourceDirectory, program.UseCaseSensitiveFileNames())
+    if resolved := getSourceFileFromReference(program, file, reference); resolved != nil {
+      resolvedPathReferences[rawPath] = resolved.Path()
+    }
+  }
   out := make([]string, 0, set.Len())
+  seen := collections.Set[tspath.Path]{}
   for path := range set.Keys() {
+    if resolved := resolvedPathReferences[path]; resolved != "" {
+      path = resolved
+    }
+    if seen.Has(path) {
+      continue
+    }
+    seen.Add(path)
     out = append(out, string(path))
   }
   return out
 }
 
+// getSourceFileFromReference extends TypeScript-Go's resident-file lookup with
+// the virtual declaration outputs its project-reference filesystem accepts.
+// The upstream helper cannot see an unbuilt output in Program.filesByPath, but
+// the project-reference mapper retains the output-to-source redirect that made
+// the reference valid while the Program was loaded.
+func getSourceFileFromReference(program *Program, file *innerast.SourceFile, reference *innerast.FileReference) *innerast.SourceFile {
+  if resolved := program.GetSourceFileFromReference(file, reference); resolved != nil {
+    return resolved
+  }
+  referencedFile := tspath.ResolvePath(tspath.GetDirectoryPath(file.FileName()), reference.FileName)
+  if tspath.HasExtension(referencedFile) {
+    return nil
+  }
+  supportedExtensions := innertsoptions.GetSupportedExtensions(program.Options(), nil)
+  supportedExtensions = innertsoptions.GetSupportedExtensionsWithJsonIfResolveJsonModule(program.Options(), supportedExtensions)
+  for _, extension := range supportedExtensions[0] {
+    outputPath := tspath.ToPath(referencedFile+extension, program.GetCurrentDirectory(), program.UseCaseSensitiveFileNames())
+    redirect := program.GetProjectReferenceFromOutputDts(outputPath)
+    if redirect == nil {
+      continue
+    }
+    if source := program.GetSourceFile(redirect.Source); source != nil {
+      return source
+    }
+  }
+  return nil
+}
+
 // FileAffectsGlobalScope reports whether editing `file` can change the global
 // scope: global-scope module augmentations, ambient declaration files, and
 // script (non-module) files. Mirrors the predicate tsgo's incremental engine

package/shim-vendor/shim/compiler/resolution.go

@@ -0,0 +1,444 @@
+// gen_shims:hand-maintained
+
+package compiler
+
+import (
+  "strings"
+  "time"
+
+  "github.com/microsoft/typescript-go/internal/ast"
+  "github.com/microsoft/typescript-go/internal/collections"
+  "github.com/microsoft/typescript-go/internal/core"
+  "github.com/microsoft/typescript-go/internal/module"
+  "github.com/microsoft/typescript-go/internal/symlinks"
+  "github.com/microsoft/typescript-go/internal/tsoptions"
+  "github.com/microsoft/typescript-go/internal/tspath"
+  "github.com/microsoft/typescript-go/internal/vfs"
+  "github.com/microsoft/typescript-go/internal/vfs/cachedvfs"
+)
+
+// ProgramResolutionKind distinguishes module and type-reference resolution.
+type ProgramResolutionKind uint8
+
+const (
+  ProgramResolutionKindModule ProgramResolutionKind = iota
+  ProgramResolutionKindTypeReference
+)
+
+// ProgramResolutionTask is one resolution already performed by a resident
+// Program. The exported fields provide deterministic host ordering while the
+// unexported fields retain the exact compiler context needed for replay.
+type ProgramResolutionTask struct {
+  ContainingFile string
+  Kind           ProgramResolutionKind
+  Mode           core.ResolutionMode
+  Name           string
+  ResolvedFile   string
+  SourceFile     string
+  TargetFile     string
+  Universal      bool
+
+  compilerOptions     *core.CompilerOptions
+  currentDirectory    string
+  expected            programResolutionResult
+  projectReferences   *projectReferenceResolutionContext
+  redirectedReference module.ResolvedProjectReference
+}
+
+// ProgramResolutionTasks returns every cached module and type-reference
+// resolution, including unresolved entries and automatic type directives.
+func ProgramResolutionTasks(program *Program) []ProgramResolutionTask {
+  if program == nil {
+    return nil
+  }
+  projectReferences := newProjectReferenceResolutionContext(program)
+  tasks := []ProgramResolutionTask{}
+  appendTask := func(kind ProgramResolutionKind, name string, mode core.ResolutionMode, filePath tspath.Path, expected programResolutionResult) {
+    containingFile := string(filePath)
+    sourceFile := ""
+    targetFile := ""
+    var redirectedReference module.ResolvedProjectReference
+    if source := program.GetSourceFileByPath(filePath); source != nil {
+      sourceFile = source.FileName()
+      redirectedReference, containingFile = programResolutionContext(program, source)
+    }
+    if target := program.GetSourceFileForResolvedModule(expected.resolvedFileName); target != nil {
+      targetFile = target.FileName()
+    }
+    tasks = append(tasks, ProgramResolutionTask{
+      ContainingFile:      containingFile,
+      Kind:                kind,
+      Mode:                mode,
+      Name:                name,
+      ResolvedFile:        expected.resolvedFileName,
+      SourceFile:          sourceFile,
+      TargetFile:          targetFile,
+      Universal:           strings.HasSuffix(containingFile, module.InferredTypesContainingFile),
+      compilerOptions:     program.Options(),
+      currentDirectory:    program.GetCurrentDirectory(),
+      expected:            expected,
+      projectReferences:   projectReferences,
+      redirectedReference: redirectedReference,
+    })
+  }
+  program.ForEachResolvedModule(func(resolution *module.ResolvedModule, name string, mode core.ResolutionMode, filePath tspath.Path) {
+    appendTask(ProgramResolutionKindModule, name, mode, filePath, moduleResolutionResult(resolution))
+  }, nil)
+  program.ForEachResolvedTypeReferenceDirective(func(resolution *module.ResolvedTypeReferenceDirective, name string, mode core.ResolutionMode, filePath tspath.Path) {
+    appendTask(ProgramResolutionKindTypeReference, name, mode, filePath, typeReferenceResolutionResult(resolution))
+  }, nil)
+  return tasks
+}
+
+// programResolutionContext mirrors projectReferenceFileMapper's containing
+// file substitution using the public Program maps. The selected source path is
+// part of resolution semantics, not merely diagnostic provenance.
+func programResolutionContext(program *Program, source ast.HasFileName) (module.ResolvedProjectReference, string) {
+  if redirected := program.GetProjectReferenceFromSource(source.Path()); redirected != nil {
+    return redirected.Resolved, redirected.Source
+  }
+  if redirected := program.GetProjectReferenceFromOutputDts(source.Path()); redirected != nil {
+    return redirected.Resolved, redirected.Source
+  }
+  redirect := program.GetRedirectForResolution(source)
+  if redirect == nil {
+    return nil, source.FileName()
+  }
+  // The remaining redirect form is a preserved node_modules symlink whose
+  // physical declaration belongs to a project reference. Resolve the same
+  // physical key the compiler mapper used and retain the original source name.
+  realpath := program.Host().FS().Realpath(source.FileName())
+  path := tspath.ToPath(realpath, program.GetCurrentDirectory(), program.UseCaseSensitiveFileNames())
+  if redirected := program.GetProjectReferenceFromOutputDts(path); redirected != nil {
+    return redirected.Resolved, redirected.Source
+  }
+  // A concurrent retarget can make the public lookup disappear after the
+  // resident redirect was cached. Keep the redirect so replay necessarily
+  // disagrees with the resident result or its observed identity proof fails.
+  return redirect, source.FileName()
+}
+
+// ReplayProgramResolutions resolves one source's tasks with one fresh upstream
+// resolver and reports whether every result still matches the resident Program.
+func ReplayProgramResolutions(tasks []ProgramResolutionTask, filesystem vfs.FS) bool {
+  if len(tasks) == 0 || filesystem == nil || tasks[0].compilerOptions == nil {
+    return false
+  }
+  first := tasks[0]
+  host := resolutionHost{
+    filesystem:       first.projectReferences.filesystem(filesystem),
+    currentDirectory: first.currentDirectory,
+  }
+  resolver := module.NewResolver(host, first.compilerOptions, "", "")
+  matches := true
+  for _, task := range tasks {
+    var actual programResolutionResult
+    switch task.Kind {
+    case ProgramResolutionKindModule:
+      resolution, _ := resolver.ResolveModuleName(task.Name, task.ContainingFile, task.Mode, task.redirectedReference)
+      actual = moduleResolutionResult(resolution)
+    case ProgramResolutionKindTypeReference:
+      resolution, _ := resolver.ResolveTypeReferenceDirective(task.Name, task.ContainingFile, task.Mode, task.redirectedReference)
+      actual = typeReferenceResolutionResult(resolution)
+    default:
+      matches = false
+      continue
+    }
+    if actual != task.expected {
+      matches = false
+    }
+  }
+  return matches
+}
+
+// projectReferenceResolutionContext snapshots the immutable metadata needed to
+// recreate fileLoader's project-reference declaration view for every replay
+// filesystem. A referenced output declaration may be absent on disk while its
+// source exists; the resolver must see the virtual declaration before Program
+// substitutes that source into the loaded graph.
+type projectReferenceResolutionContext struct {
+  currentDirectory            string
+  dtsDirectories              collections.Set[tspath.Path]
+  outputDtsToProjectReference map[tspath.Path]*tsoptions.SourceOutputAndProjectReference
+}
+
+func newProjectReferenceResolutionContext(program *Program) *projectReferenceResolutionContext {
+  if program == nil {
+    return nil
+  }
+  outputDtsToProjectReference := map[tspath.Path]*tsoptions.SourceOutputAndProjectReference{}
+  dtsDirectories := collections.Set[tspath.Path]{}
+  useSourceOfProjectReference := false
+  program.RangeResolvedProjectReference(func(_ tspath.Path, config *tsoptions.ParsedCommandLine, _ *tsoptions.ParsedCommandLine, _ int) bool {
+    if config == nil {
+      return true
+    }
+    config.ParseInputOutputNames()
+    for path := range config.SourceToProjectReference() {
+      useSourceOfProjectReference = useSourceOfProjectReference || program.IsSourceFromProjectReference(path)
+    }
+    for path, reference := range config.OutputDtsToProjectReference() {
+      outputDtsToProjectReference[path] = reference
+    }
+    declarationDirectory := config.CompilerOptions().DeclarationDir
+    if declarationDirectory == "" {
+      declarationDirectory = config.CompilerOptions().OutDir
+    }
+    if declarationDirectory != "" {
+      dtsDirectories.Add(tspath.ToPath(declarationDirectory, program.GetCurrentDirectory(), program.UseCaseSensitiveFileNames()))
+    }
+    return true
+  })
+  if !useSourceOfProjectReference || len(outputDtsToProjectReference) == 0 {
+    return nil
+  }
+  return &projectReferenceResolutionContext{
+    currentDirectory:            program.GetCurrentDirectory(),
+    dtsDirectories:              dtsDirectories,
+    outputDtsToProjectReference: outputDtsToProjectReference,
+  }
+}
+
+func (context *projectReferenceResolutionContext) filesystem(filesystem vfs.FS) vfs.FS {
+  if context == nil || filesystem == nil {
+    return filesystem
+  }
+  return cachedvfs.From(&projectReferenceResolutionFS{
+    filesystem:                  filesystem,
+    currentDirectory:            context.currentDirectory,
+    dtsDirectories:              context.dtsDirectories,
+    knownSymlinks:               symlinks.KnownSymlinks{},
+    outputDtsToProjectReference: context.outputDtsToProjectReference,
+  })
+}
+
+// projectReferenceResolutionFS mirrors TypeScript-Go's
+// projectReferenceDtsFakingVfs over the caller's observation filesystem.
+type projectReferenceResolutionFS struct {
+  filesystem                  vfs.FS
+  currentDirectory            string
+  dtsDirectories              collections.Set[tspath.Path]
+  knownSymlinks               symlinks.KnownSymlinks
+  outputDtsToProjectReference map[tspath.Path]*tsoptions.SourceOutputAndProjectReference
+}
+
+var _ vfs.FS = (*projectReferenceResolutionFS)(nil)
+
+func (fs *projectReferenceResolutionFS) UseCaseSensitiveFileNames() bool {
+  return fs.filesystem.UseCaseSensitiveFileNames()
+}
+
+func (fs *projectReferenceResolutionFS) FileExists(path string) bool {
+  if fs.filesystem.FileExists(path) {
+    return true
+  }
+  if !tspath.IsDeclarationFileName(path) {
+    return false
+  }
+  return fs.fileOrDirectoryExistsUsingSource(path, true)
+}
+
+func (fs *projectReferenceResolutionFS) ReadFile(path string) (string, bool) {
+  return fs.filesystem.ReadFile(path)
+}
+
+func (fs *projectReferenceResolutionFS) WriteFile(string, string) error {
+  panic("should not be called by resolver")
+}
+
+func (fs *projectReferenceResolutionFS) AppendFile(string, string) error {
+  panic("should not be called by resolver")
+}
+
+func (fs *projectReferenceResolutionFS) Remove(string) error {
+  panic("should not be called by resolver")
+}
+
+func (fs *projectReferenceResolutionFS) Chtimes(string, time.Time, time.Time) error {
+  panic("should not be called by resolver")
+}
+
+func (fs *projectReferenceResolutionFS) DirectoryExists(path string) bool {
+  if fs.filesystem.DirectoryExists(path) {
+    fs.handleDirectoryCouldBeSymlink(path)
+    return true
+  }
+  return fs.fileOrDirectoryExistsUsingSource(path, false)
+}
+
+func (fs *projectReferenceResolutionFS) GetAccessibleEntries(string) vfs.Entries {
+  panic("should not be called by resolver")
+}
+
+func (fs *projectReferenceResolutionFS) Stat(string) vfs.FileInfo {
+  panic("should not be called by resolver")
+}
+
+func (fs *projectReferenceResolutionFS) WalkDir(string, vfs.WalkDirFunc) error {
+  panic("should not be called by resolver")
+}
+
+func (fs *projectReferenceResolutionFS) Realpath(path string) string {
+  if result, ok := fs.knownSymlinks.Files().Load(fs.toPath(path)); ok {
+    return result
+  }
+  return fs.filesystem.Realpath(path)
+}
+
+func (fs *projectReferenceResolutionFS) toPath(path string) tspath.Path {
+  return tspath.ToPath(path, fs.currentDirectory, fs.UseCaseSensitiveFileNames())
+}
+
+func (fs *projectReferenceResolutionFS) handleDirectoryCouldBeSymlink(directory string) {
+  if tspath.ContainsIgnoredPath(directory) || !strings.Contains(directory, "/node_modules/") {
+    return
+  }
+  directoryPath := tspath.Path(tspath.EnsureTrailingDirectorySeparator(string(fs.toPath(directory))))
+  if _, ok := fs.knownSymlinks.Directories().Load(directoryPath); ok {
+    return
+  }
+  realDirectory := fs.Realpath(directory)
+  if realDirectory == directory {
+    return
+  }
+  realPath := tspath.Path(tspath.EnsureTrailingDirectorySeparator(string(fs.toPath(realDirectory))))
+  if realPath == directoryPath {
+    return
+  }
+  fs.knownSymlinks.SetDirectory(directory, directoryPath, &symlinks.KnownDirectoryLink{
+    Real:     tspath.EnsureTrailingDirectorySeparator(realDirectory),
+    RealPath: realPath,
+  })
+}
+
+func (fs *projectReferenceResolutionFS) fileOrDirectoryExistsUsingSource(fileOrDirectory string, isFile bool) bool {
+  existence := fs.directoryExistsIfProjectReferenceDeclarationDirectory
+  if isFile {
+    existence = fs.fileExistsIfProjectReferenceDeclaration
+  }
+  result := existence(fileOrDirectory)
+  if result != core.TSUnknown {
+    return result == core.TSTrue
+  }
+  knownDirectoryLinks := fs.knownSymlinks.Directories()
+  if knownDirectoryLinks.Size() == 0 {
+    return false
+  }
+  fileOrDirectoryPath := fs.toPath(fileOrDirectory)
+  if !strings.Contains(string(fileOrDirectoryPath), "/node_modules/") {
+    return false
+  }
+  if isFile {
+    if _, ok := fs.knownSymlinks.Files().Load(fileOrDirectoryPath); ok {
+      return true
+    }
+  }
+  exists := false
+  knownDirectoryLinks.Range(func(directoryPath tspath.Path, knownDirectoryLink *symlinks.KnownDirectoryLink) bool {
+    relative, hasPrefix := strings.CutPrefix(string(fileOrDirectoryPath), string(directoryPath))
+    if !hasPrefix {
+      return true
+    }
+    if exists = existence(string(knownDirectoryLink.RealPath) + relative).IsTrue(); !exists {
+      return true
+    }
+    if isFile {
+      absolutePath := tspath.GetNormalizedAbsolutePath(fileOrDirectory, fs.currentDirectory)
+      fs.knownSymlinks.SetFile(
+        absolutePath,
+        fileOrDirectoryPath,
+        knownDirectoryLink.Real+absolutePath[len(directoryPath):],
+      )
+    }
+    return false
+  })
+  return exists
+}
+
+func (fs *projectReferenceResolutionFS) fileExistsIfProjectReferenceDeclaration(file string) core.Tristate {
+  reference := fs.outputDtsToProjectReference[fs.toPath(file)]
+  if reference == nil {
+    return core.TSUnknown
+  }
+  return core.IfElse(fs.filesystem.FileExists(reference.Source), core.TSTrue, core.TSFalse)
+}
+
+func (fs *projectReferenceResolutionFS) directoryExistsIfProjectReferenceDeclarationDirectory(directory string) core.Tristate {
+  directoryPath := fs.toPath(directory)
+  directoryPathWithSeparator := directoryPath + "/"
+  for declarationDirectoryPath := range fs.dtsDirectories.Keys() {
+    if directoryPath == declarationDirectoryPath || strings.HasPrefix(string(declarationDirectoryPath), string(directoryPathWithSeparator)) || strings.HasPrefix(string(directoryPath), string(declarationDirectoryPath)+"/") {
+      return core.TSTrue
+    }
+  }
+  return core.TSUnknown
+}
+
+// ReplayAutomaticTypeDirectiveDiscovery repeats the compiler's exact wildcard
+// type-root enumeration over filesystem so a host can observe its inputs.
+func ReplayAutomaticTypeDirectiveDiscovery(program *Program, filesystem vfs.FS) {
+  if program == nil || filesystem == nil || program.Options() == nil {
+    return
+  }
+  module.GetAutomaticTypeDirectiveNames(program.Options(), resolutionHost{
+    filesystem:       filesystem,
+    currentDirectory: program.GetCurrentDirectory(),
+  })
+}
+
+type resolutionHost struct {
+  filesystem       vfs.FS
+  currentDirectory string
+}
+
+func (host resolutionHost) FS() vfs.FS { return host.filesystem }
+
+func (host resolutionHost) GetCurrentDirectory() string { return host.currentDirectory }
+
+type programResolutionResult struct {
+  alternateResult          string
+  extension                string
+  isExternalLibraryImport  bool
+  originalPath             string
+  packageName              string
+  packagePeerDependencies  string
+  packageSubModuleName     string
+  packageVersion           string
+  primary                  bool
+  resolvedFileName         string
+  resolvedUsingTsExtension bool
+}
+
+func moduleResolutionResult(resolution *module.ResolvedModule) programResolutionResult {
+  if resolution == nil {
+    return programResolutionResult{}
+  }
+  return programResolutionResult{
+    alternateResult:          resolution.AlternateResult,
+    extension:                resolution.Extension,
+    isExternalLibraryImport:  resolution.IsExternalLibraryImport,
+    originalPath:             resolution.OriginalPath,
+    packageName:              resolution.PackageId.Name,
+    packagePeerDependencies:  resolution.PackageId.PeerDependencies,
+    packageSubModuleName:     resolution.PackageId.SubModuleName,
+    packageVersion:           resolution.PackageId.Version,
+    resolvedFileName:         resolution.ResolvedFileName,
+    resolvedUsingTsExtension: resolution.ResolvedUsingTsExtension,
+  }
+}
+
+func typeReferenceResolutionResult(resolution *module.ResolvedTypeReferenceDirective) programResolutionResult {
+  if resolution == nil {
+    return programResolutionResult{}
+  }
+  return programResolutionResult{
+    isExternalLibraryImport: resolution.IsExternalLibraryImport,
+    originalPath:            resolution.OriginalPath,
+    packageName:             resolution.PackageId.Name,
+    packagePeerDependencies: resolution.PackageId.PeerDependencies,
+    packageSubModuleName:    resolution.PackageId.SubModuleName,
+    packageVersion:          resolution.PackageId.Version,
+    primary:                 resolution.Primary,
+    resolvedFileName:        resolution.ResolvedFileName,
+  }
+}

package/shim-vendor/shim/core/shim.go

@@ -6,7 +6,10 @@
 // primitives without exposing the full internal surface.
 package core
 
-import innercore "github.com/microsoft/typescript-go/internal/core"
+import (
+  innercore "github.com/microsoft/typescript-go/internal/core"
+  innersemver "github.com/microsoft/typescript-go/internal/semver"
+)
 
 // CompilerOptions holds the parsed tsconfig compiler options passed to the
 // TypeScript-Go program host.
@@ -96,6 +99,17 @@ const (
 // consumer can tell which checker resolved the facts it is reading.
 func Version() string { return innercore.Version() }
 
+// TypeScriptVersionSatisfiesRange reports whether the compiler's own version
+// satisfies a typesVersions range under TypeScript-Go's semver grammar.
+func TypeScriptVersionSatisfiesRange(text string) bool {
+  versionRange, ok := innersemver.TryParseVersionRange(text)
+  if !ok {
+    return false
+  }
+  version, err := innersemver.TryParseVersion(innercore.Version())
+  return err == nil && versionRange.Test(&version)
+}
+
 // ComputeECMALineStarts applies the compiler's LF, CRLF, CR, LS, and PS line
 // model to UTF-8 source text.
 func ComputeECMALineStarts(text string) ECMALineStarts {