ttsc 0.19.3 → 0.20.0

package/cmd/ttscgraph/serve.go

@@ -14,7 +14,6 @@ import (
   "sort"
   "strings"
 
-  shimast "github.com/microsoft/typescript-go/shim/ast"
   shimtsoptions "github.com/microsoft/typescript-go/shim/tsoptions"
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 
@@ -128,6 +127,10 @@ type graphSession struct {
   configDigests []graph.FileDigest
   roots         []graph.RootFile
   initialized   bool
+  // pendingDumpMode remembers a generation whose state was captured but whose
+  // dump failed. Until an input change lets the session rebuild, an unchanged
+  // request must retry that dump instead of falsely confirming the older graph.
+  pendingDumpMode string
 }
 
 func newGraphSession(cwd, tsconfig string) (*graphSession, error) {
@@ -147,8 +150,17 @@ func (s *graphSession) Close() error {
 
 func (s *graphSession) Snapshot() (*graph.Dump, string, bool, error) {
   if !s.initialized {
-    dump := s.buildDump()
+    // The captured compiler state is initialized even when its first dump is
+    // not publishable. Mark the attempt before building so a later request can
+    // observe a config/source edit that repairs the path error instead of
+    // retrying the stale Program forever.
     s.initialized = true
+    dump, err := s.buildDump()
+    if err != nil {
+      s.pendingDumpMode = serveModeInitial
+      return nil, "", false, err
+    }
+    s.pendingDumpMode = ""
     return &dump, serveModeInitial, true, nil
   }
 
@@ -160,16 +172,14 @@ func (s *graphSession) Snapshot() (*graph.Dump, string, bool, error) {
     if err := s.reload(); err != nil {
       return nil, "", false, err
     }
-    dump := s.buildDump()
-    return &dump, serveModeReload, true, nil
+    return s.changedSnapshot(serveModeReload)
   }
 
   if diskStatesChanged(s.auxStates) {
     if err := s.reload(); err != nil {
       return nil, "", false, err
     }
-    dump := s.buildDump()
-    return &dump, serveModeReload, true, nil
+    return s.changedSnapshot(serveModeReload)
   }
 
   roots, err := projectRootFiles(s.compiler.Program(), true)
@@ -180,8 +190,7 @@ func (s *graphSession) Snapshot() (*graph.Dump, string, bool, error) {
     if err := s.reload(); err != nil {
       return nil, "", false, err
     }
-    dump := s.buildDump()
-    return &dump, serveModeReload, true, nil
+    return s.changedSnapshot(serveModeReload)
   }
 
   changed, deleted, err := changedSources(s.sourceHashes)
@@ -192,18 +201,19 @@ func (s *graphSession) Snapshot() (*graph.Dump, string, bool, error) {
     if err := s.reload(); err != nil {
       return nil, "", false, err
     }
-    dump := s.buildDump()
-    return &dump, serveModeReload, true, nil
+    return s.changedSnapshot(serveModeReload)
   }
   if len(changed) == 0 {
+    if s.pendingDumpMode != "" {
+      return s.changedSnapshot(s.pendingDumpMode)
+    }
     return nil, serveModeUnchanged, false, nil
   }
   if s.compiler.Program().HasLinkedProgramPlugins() {
     if err := s.reload(); err != nil {
       return nil, "", false, err
     }
-    dump := s.buildDump()
-    return &dump, serveModeReload, true, nil
+    return s.changedSnapshot(serveModeReload)
   }
 
   mode := serveModeIncremental
@@ -222,14 +232,22 @@ func (s *graphSession) Snapshot() (*graph.Dump, string, bool, error) {
       if err := s.reload(); err != nil {
         return nil, "", false, err
       }
-      dump := s.buildDump()
-      return &dump, serveModeReload, true, nil
+      return s.changedSnapshot(serveModeReload)
     }
   }
   if err := s.captureState(); err != nil {
     return nil, "", false, err
   }
-  dump := s.buildDump()
+  return s.changedSnapshot(mode)
+}
+
+func (s *graphSession) changedSnapshot(mode string) (*graph.Dump, string, bool, error) {
+  dump, err := s.buildDump()
+  if err != nil {
+    s.pendingDumpMode = mode
+    return nil, "", false, err
+  }
+  s.pendingDumpMode = ""
   return &dump, mode, true, nil
 }
 
@@ -323,7 +341,7 @@ func missingRootInputs(configs []*shimtsoptions.ParsedCommandLine, sourceHashes
   return missing
 }
 
-func (s *graphSession) buildDump() graph.Dump {
+func (s *graphSession) buildDump() (graph.Dump, error) {
   program := s.compiler.Program()
   built := graph.Build(program)
   // One texts map feeds both the spans and the manifest digests, so the bytes a
@@ -337,7 +355,6 @@ func (s *graphSession) buildDump() graph.Dump {
     texts,
     graph.DumpOrigin{
       Provenance: graph.NewProvenance(
-        s.cwd,
         serveProducer(),
         fullSnapshotCapabilities,
         s.configDigests,
@@ -345,7 +362,7 @@ func (s *graphSession) buildDump() graph.Dump {
         texts,
         s.diskDigests,
       ),
-      Diagnostics: graph.NewDiagnostics(program, s.cwd),
+      Diagnostics: graph.NewDiagnostics(program),
     },
   )
 }
@@ -553,11 +570,6 @@ type diskState struct {
   Exists bool
 }
 
-type packageTarget struct {
-  path     string
-  wildcard string
-}
-
 // captureDiskStates records the freshness state of speculative resolution
 // candidates. Most candidates do not exist, and a module specifier can name a
 // path the host OS cannot even parse (`./style.css?inline`, a `data:` URL on
@@ -614,17 +626,35 @@ func auxiliaryInputs(program *driver.Program, configs []*shimtsoptions.ParsedCom
     directory := filepath.Dir(file)
     inputs = appendAncestorInputs(inputs, directory, cwd)
     for _, reference := range source.ReferencedFiles {
-      inputs = append(inputs, fileCandidates(filepath.Join(directory, filepath.FromSlash(reference.FileName)))...)
+      inputs = append(inputs, driver.FileCandidates(filepath.Join(directory, filepath.FromSlash(reference.FileName)))...)
     }
     for _, reference := range source.TypeReferenceDirectives {
-      inputs = append(inputs, typeReferenceCandidates(configs, directory, cwd, reference.FileName)...)
+      inputs = append(inputs, driver.TypeReferenceCandidates(configs, directory, cwd, reference.FileName)...)
     }
-    for _, specifier := range sourceModuleSpecifiers(source) {
+    for _, specifier := range driver.SourceModuleSpecifiers(source) {
+      context := driver.ModuleResolutionContext{
+        Mode: program.TSProgram.GetModeForUsageLocation(source, specifier),
+      }
+      for _, parsed := range configs {
+        if parsed != nil && parsed.ParsedConfig != nil && parsed.ParsedConfig.CompilerOptions != nil {
+          context.Options = parsed.ParsedConfig.CompilerOptions
+          break
+        }
+      }
       resolved := program.TSProgram.GetResolvedModuleFromModuleSpecifier(source, specifier)
       if resolved != nil && resolved.IsResolved() {
+        inputs = append(inputs, driver.ModuleResolutionPredecessors(
+          configs,
+          directory,
+          cwd,
+          specifier.Text(),
+          resolved.ResolvedFileName,
+          program.FS.UseCaseSensitiveFileNames(),
+          context,
+        )...)
         continue
       }
-      inputs = append(inputs, unresolvedModuleCandidates(configs, directory, cwd, specifier.Text())...)
+      inputs = append(inputs, driver.ModuleResolutionCandidates(configs, directory, cwd, specifier.Text(), context)...)
     }
   }
   // Config `types` entries request type packages without any source syntax, so
@@ -635,82 +665,12 @@ func auxiliaryInputs(program *driver.Program, configs []*shimtsoptions.ParsedCom
       continue
     }
     for _, name := range parsed.ParsedConfig.CompilerOptions.Types {
-      inputs = append(inputs, typeReferenceCandidates(configs, parsed.GetCurrentDirectory(), cwd, name)...)
+      inputs = append(inputs, driver.TypeReferenceCandidates(configs, parsed.GetCurrentDirectory(), cwd, name)...)
     }
   }
   return compactSortedStrings(inputs)
 }
 
-func typeReferenceCandidates(configs []*shimtsoptions.ParsedCommandLine, directory, cwd, name string) []string {
-  candidates := []string{}
-  for _, parsed := range configs {
-    if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
-      continue
-    }
-    for _, root := range parsed.ParsedConfig.CompilerOptions.TypeRoots {
-      candidates = append(candidates, fileCandidates(filepath.Join(root, filepath.FromSlash(name)))...)
-    }
-  }
-  for current := filepath.Clean(directory); ; current = filepath.Dir(current) {
-    candidates = append(candidates, fileCandidates(filepath.Join(current, "node_modules", "@types", filepath.FromSlash(name)))...)
-    if current == filepath.Clean(cwd) || filepath.Dir(current) == current {
-      return candidates
-    }
-  }
-}
-
-func sourceModuleSpecifiers(source *shimast.SourceFile) []*shimast.Node {
-  if source == nil {
-    return nil
-  }
-  specifiers := []*shimast.Node{}
-  var walk func(*shimast.Node) bool
-  walk = func(node *shimast.Node) bool {
-    if node == nil {
-      return false
-    }
-    var specifier *shimast.Node
-    switch node.Kind {
-    case shimast.KindImportDeclaration, shimast.KindJSImportDeclaration:
-      specifier = node.AsImportDeclaration().ModuleSpecifier
-    case shimast.KindExportDeclaration:
-      specifier = node.AsExportDeclaration().ModuleSpecifier
-    case shimast.KindImportEqualsDeclaration:
-      reference := node.AsImportEqualsDeclaration().ModuleReference
-      if reference != nil && reference.Kind == shimast.KindExternalModuleReference {
-        specifier = reference.AsExternalModuleReference().Expression
-      }
-    case shimast.KindImportType:
-      argument := node.AsImportTypeNode().Argument
-      if argument != nil && argument.Kind == shimast.KindLiteralType {
-        specifier = argument.AsLiteralTypeNode().Literal
-      }
-    case shimast.KindCallExpression:
-      call := node.AsCallExpression()
-      if isModuleSpecifierCall(call) && call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-        specifier = call.Arguments.Nodes[0]
-      }
-    }
-    if specifier != nil && (specifier.Kind == shimast.KindStringLiteral || specifier.Kind == shimast.KindNoSubstitutionTemplateLiteral) {
-      specifiers = append(specifiers, specifier)
-    }
-    node.ForEachChild(walk)
-    return false
-  }
-  walk(source.AsNode())
-  return specifiers
-}
-
-func isModuleSpecifierCall(call *shimast.CallExpression) bool {
-  if call == nil || call.Expression == nil {
-    return false
-  }
-  if call.Expression.Kind == shimast.KindImportKeyword {
-    return true
-  }
-  return call.Expression.Kind == shimast.KindIdentifier && call.Expression.Text() == "require"
-}
-
 func appendAncestorInputs(inputs []string, directory, stop string) []string {
   stop = filepath.Clean(stop)
   for current := filepath.Clean(directory); ; current = filepath.Dir(current) {
@@ -721,216 +681,6 @@ func appendAncestorInputs(inputs []string, directory, stop string) []string {
   }
 }
 
-func unresolvedModuleCandidates(configs []*shimtsoptions.ParsedCommandLine, directory, cwd, specifier string) []string {
-  if specifier == "" {
-    return nil
-  }
-  if strings.HasPrefix(specifier, ".") {
-    candidates := fileCandidates(filepath.Clean(filepath.Join(directory, filepath.FromSlash(specifier))))
-    return append(candidates, rootDirsCandidates(configs, directory, specifier)...)
-  }
-  candidates := compilerOptionCandidates(configs, specifier)
-  if strings.HasPrefix(specifier, "#") {
-    for current := filepath.Clean(directory); ; current = filepath.Dir(current) {
-      candidates = append(candidates, packageManifestCandidates(current, specifier)...)
-      if current == filepath.Clean(cwd) || filepath.Dir(current) == current {
-        return candidates
-      }
-    }
-  }
-  for current := filepath.Clean(directory); ; current = filepath.Dir(current) {
-    base := filepath.Join(current, "node_modules", filepath.FromSlash(specifier))
-    root := packageRoot(base, specifier)
-    candidates = append(candidates, fileCandidates(base)...)
-    candidates = append(candidates, filepath.Join(root, "package.json"))
-    candidates = append(candidates, packageManifestCandidates(root, packageSubpath(specifier))...)
-    if current == filepath.Clean(cwd) || filepath.Dir(current) == current {
-      break
-    }
-  }
-  return candidates
-}
-
-func packageManifestCandidates(root, wildcard string) []string {
-  content, err := os.ReadFile(filepath.Join(root, "package.json"))
-  if err != nil {
-    return nil
-  }
-  var manifest struct {
-    Main          string `json:"main"`
-    Module        string `json:"module"`
-    Types         string `json:"types"`
-    Typings       string `json:"typings"`
-    Exports       any    `json:"exports"`
-    Imports       any    `json:"imports"`
-    TypesVersions any    `json:"typesVersions"`
-  }
-  if json.Unmarshal(content, &manifest) != nil {
-    return nil
-  }
-  defaultWildcard := strings.TrimPrefix(strings.TrimPrefix(wildcard, "./"), "#")
-  targets := []packageTarget{
-    {path: manifest.Main, wildcard: defaultWildcard},
-    {path: manifest.Module, wildcard: defaultWildcard},
-    {path: manifest.Types, wildcard: defaultWildcard},
-    {path: manifest.Typings, wildcard: defaultWildcard},
-  }
-  exportRequest := "."
-  if wildcard != "" && !strings.HasPrefix(wildcard, "#") {
-    exportRequest = "./" + strings.TrimPrefix(wildcard, "./")
-  }
-  collectPackageMappingTargets(manifest.Exports, exportRequest, defaultWildcard, &targets)
-  collectPackageMappingTargets(manifest.Imports, wildcard, defaultWildcard, &targets)
-  collectPackageTargets(manifest.TypesVersions, defaultWildcard, &targets)
-  candidates := []string{}
-  for _, target := range targets {
-    if target.path == "" || filepath.IsAbs(target.path) || strings.Contains(target.path, "://") {
-      continue
-    }
-    path := strings.Replace(target.path, "*", target.wildcard, 1)
-    candidates = append(candidates, fileCandidates(filepath.Join(root, filepath.FromSlash(path)))...)
-  }
-  return candidates
-}
-
-func collectPackageMappingTargets(value any, request, wildcard string, targets *[]packageTarget) {
-  if object, ok := value.(map[string]any); ok {
-    mapping := false
-    for key := range object {
-      if strings.HasPrefix(key, ".") || strings.HasPrefix(key, "#") {
-        mapping = true
-        break
-      }
-    }
-    if mapping {
-      for pattern, child := range object {
-        matched, ok := matchPathPattern(pattern, request)
-        if ok {
-          collectPackageTargets(child, matched, targets)
-        }
-      }
-      return
-    }
-  }
-  collectPackageTargets(value, wildcard, targets)
-}
-
-func collectPackageTargets(value any, wildcard string, targets *[]packageTarget) {
-  switch value := value.(type) {
-  case string:
-    *targets = append(*targets, packageTarget{path: value, wildcard: wildcard})
-  case []any:
-    for _, child := range value {
-      collectPackageTargets(child, wildcard, targets)
-    }
-  case map[string]any:
-    for _, child := range value {
-      collectPackageTargets(child, wildcard, targets)
-    }
-  }
-}
-
-func packageSubpath(specifier string) string {
-  parts := strings.Split(filepath.ToSlash(specifier), "/")
-  count := 1
-  if strings.HasPrefix(specifier, "@") && len(parts) > 1 {
-    count = 2
-  }
-  if len(parts) <= count {
-    return ""
-  }
-  return strings.Join(parts[count:], "/")
-}
-
-func compilerOptionCandidates(configs []*shimtsoptions.ParsedCommandLine, specifier string) []string {
-  candidates := []string{}
-  for _, parsed := range configs {
-    if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
-      continue
-    }
-    options := parsed.ParsedConfig.CompilerOptions
-    if options.BaseUrl != "" {
-      candidates = append(candidates, fileCandidates(filepath.Join(options.BaseUrl, filepath.FromSlash(specifier)))...)
-    }
-    if options.Paths == nil {
-      continue
-    }
-    base := options.GetPathsBasePath(parsed.GetCurrentDirectory())
-    for pattern, targets := range options.Paths.Entries() {
-      matched, ok := matchPathPattern(pattern, specifier)
-      if !ok {
-        continue
-      }
-      for _, target := range targets {
-        target = strings.Replace(target, "*", matched, 1)
-        candidates = append(candidates, fileCandidates(filepath.Join(base, filepath.FromSlash(target)))...)
-      }
-    }
-  }
-  return candidates
-}
-
-func rootDirsCandidates(configs []*shimtsoptions.ParsedCommandLine, directory, specifier string) []string {
-  candidates := []string{}
-  for _, parsed := range configs {
-    if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
-      continue
-    }
-    roots := parsed.ParsedConfig.CompilerOptions.RootDirs
-    for _, sourceRoot := range roots {
-      relative, err := filepath.Rel(sourceRoot, directory)
-      if err != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
-        continue
-      }
-      suffix := filepath.Join(relative, filepath.FromSlash(specifier))
-      for _, targetRoot := range roots {
-        candidates = append(candidates, fileCandidates(filepath.Join(targetRoot, suffix))...)
-      }
-    }
-  }
-  return candidates
-}
-
-func matchPathPattern(pattern, specifier string) (string, bool) {
-  star := strings.IndexByte(pattern, '*')
-  if star < 0 {
-    return "", pattern == specifier
-  }
-  prefix := pattern[:star]
-  suffix := pattern[star+1:]
-  if len(specifier) < len(prefix)+len(suffix) || !strings.HasPrefix(specifier, prefix) || !strings.HasSuffix(specifier, suffix) {
-    return "", false
-  }
-  return specifier[len(prefix) : len(specifier)-len(suffix)], true
-}
-
-func packageRoot(base, specifier string) string {
-  parts := strings.Split(filepath.ToSlash(specifier), "/")
-  count := 1
-  if strings.HasPrefix(specifier, "@") && len(parts) > 1 {
-    count = 2
-  }
-  suffixCount := len(parts) - count
-  root := base
-  for range suffixCount {
-    root = filepath.Dir(root)
-  }
-  return root
-}
-
-func fileCandidates(base string) []string {
-  candidates := []string{base}
-  extension := strings.ToLower(filepath.Ext(base))
-  if extension == ".js" || extension == ".jsx" || extension == ".mjs" || extension == ".cjs" {
-    base = strings.TrimSuffix(base, filepath.Ext(base))
-  }
-  for _, suffix := range []string{".ts", ".tsx", ".mts", ".cts", ".d.ts", ".d.mts", ".d.cts", ".js", ".jsx", ".mjs", ".cjs", ".json"} {
-    candidates = append(candidates, base+suffix, filepath.Join(base, "index"+suffix))
-  }
-  candidates = append(candidates, filepath.Join(base, "package.json"))
-  return candidates
-}
-
 func compactSortedStrings(input []string) []string {
   out := make([]string, 0, len(input))
   for _, value := range input {

package/cmd/ttscgraph/serve_session_keeps_base_url_fallback_unchanged_test.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionKeepsBaseURLFallbackUnchanged verifies an unmatched
+// baseUrl-style file does not invalidate a paths resolution.
+//
+// The pinned TypeScript-Go resolver applies a matching paths substitution and
+// does not fall back to baseUrl afterward. Recording a baseUrl probe would make
+// an irrelevant file creation rebuild a resident session without changing the
+// selected module.
+//
+//  1. Load a paths import whose configured fallback target exists.
+//  2. Create only the corresponding baseUrl-style file.
+//  3. Assert the session remains unchanged because the paths target still wins.
+func TestServeSessionKeepsBaseURLFallbackUnchanged(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "commonjs",
+    "paths": { "@generated/*": ["fallback/*"] },
+    "target": "ES2022"
+  },
+  "files": ["src/main.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { winner } from '@generated/value';\nexport function main(): void { winner(); }\n")
+  writeGraphFile(t, filepath.Join(root, "fallback", "value.ts"), "export function winner(): void {}\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+  writeGraphFile(t, filepath.Join(root, "@generated", "value.ts"), "export function winner(): void {}\n")
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != serveModeUnchanged || changed {
+    t.Fatalf("baseUrl fallback = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_keeps_esm_directory_candidate_unchanged_test.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionKeepsESMDirectoryCandidateUnchanged verifies ESM relative
+// resolution does not inherit CommonJS directory probes.
+//
+// TypeScript-Go may substitute value.ts for the explicit value.js import, but
+// it never performs the CommonJS value/package.json or value/index.* lookup in
+// ESM mode. Those directory members must therefore stay out of a resident
+// session's freshness inputs.
+func TestServeSessionKeepsESMDirectoryCandidateUnchanged(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "package.json"), `{"type":"module"}`)
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "allowJs": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "target": "ES2022"
+  },
+  "files": ["src/main.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { winner } from './value.js';\nexport function main(): void { winner(); }\n")
+  writeGraphFile(t, filepath.Join(root, "src", "value.js"), "export function winner() {}\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+
+  if err := os.MkdirAll(filepath.Join(root, "src", "value"), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  writeGraphFile(t, filepath.Join(root, "src", "value", "package.json"), `{"type":"module"}`)
+  writeGraphFile(t, filepath.Join(root, "src", "value", "index.ts"), "export function winner(): void {}\n")
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != serveModeUnchanged || changed {
+    t.Fatalf("ESM directory candidate = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  writeGraphFile(t, filepath.Join(root, "src", "value.ts"), "export function winner(): void {}\nexport function typescriptWinner(): void {}\n")
+  dump, mode, changed, err = session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != serveModeReload || !changed || !hasDumpNode(*dump, "typescriptWinner") {
+    t.Fatalf("ESM higher-priority file = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_keeps_exports_blocked_file_candidates_unchanged_test.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionKeepsExportsBlockedFileCandidatesUnchanged verifies a
+// package export map prevents unlisted bare-file candidates from invalidating a
+// resident session.
+//
+// An export map controls subpath resolution before TypeScript considers an
+// on-disk package file. Recording that blocked file as a predecessor would make
+// unrelated package contents churn the snapshot despite the selected export
+// remaining exactly the same.
+//
+//  1. Load a package subpath resolved through its export-map fallback target.
+//  2. Create an unlisted file at the bare subpath without changing package.json.
+//  3. Assert the session is unchanged, then create the export-map target that
+//     genuinely precedes the fallback and assert it reloads.
+func TestServeSessionKeepsExportsBlockedFileCandidatesUnchanged(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "allowJs": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "target": "ES2022"
+  },
+  "files": ["src/main.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { winner } from 'fixture-package/feature';\nexport function main(): void { winner(); }\n")
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "package.json"), `{
+  "name": "fixture-package",
+  "exports": { "./feature": ["./dist/first.js", "./dist/fallback.js"] }
+}`)
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "fallback.js"), "export function winner() {}\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "feature.ts"), "export function winner(): void {}\n")
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != serveModeUnchanged || changed {
+    t.Fatalf("exports-blocked feature.ts = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "first.js"), "export function winner() {}\nexport function exportsWinner() {}\n")
+  dump, mode, changed, err = session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != serveModeReload || !changed {
+    t.Fatalf("export-map first target = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}