ttsc 0.18.2 → 0.18.4

package/cmd/ttscgraph/serve_protocol_rejects_invalid_request_line_test.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+// TestServeProtocolRejectsInvalidRequestLine verifies a malformed NDJSON line
+// answers with a protocol error and never poisons the following requests.
+//
+// The launcher only ever writes well-formed requests, so a garbage line means
+// a corrupted pipe or a foreign writer; the server must report it (with the
+// zero ID, since none could be parsed) and keep serving instead of exiting.
+//
+//  1. Send a non-JSON line followed by a valid request.
+//  2. Assert the first response carries an error and no dump.
+//  3. Assert the second response is the normal initial snapshot.
+func TestServeProtocolRejectsInvalidRequestLine(t *testing.T) {
+  root := graphSessionFixture(t)
+  input := strings.NewReader("not-json\n{\"id\":1}\n")
+  var output bytes.Buffer
+
+  if code := serveSnapshots(input, &output, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("serveSnapshots exited %d", code)
+  }
+  decoder := json.NewDecoder(&output)
+  var invalid serveResponse
+  var initial serveResponse
+  if err := decoder.Decode(&invalid); err != nil {
+    t.Fatal(err)
+  }
+  if err := decoder.Decode(&initial); err != nil {
+    t.Fatal(err)
+  }
+  if invalid.ID != 0 || invalid.Error == "" || !strings.Contains(invalid.Error, "invalid request") || invalid.Dump != nil || invalid.Changed {
+    t.Fatalf("invalid line response: %#v", invalid)
+  }
+  if initial.ID != 1 || initial.Mode != "initial" || !initial.Changed || initial.Dump == nil || initial.Error != "" {
+    t.Fatalf("follow-up response: %#v", initial)
+  }
+}

package/cmd/ttscgraph/serve_protocol_retries_session_creation_test.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "io"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// stepReader hands the scanner one scripted chunk per Read call, running each
+// step's side effect at the moment the server asks for more input — after the
+// previous request has been fully answered.
+type stepReader struct {
+  steps []func() []byte
+  buf   []byte
+}
+
+func (r *stepReader) Read(p []byte) (int, error) {
+  if len(r.buf) == 0 {
+    if len(r.steps) == 0 {
+      return 0, io.EOF
+    }
+    r.buf = r.steps[0]()
+    r.steps = r.steps[1:]
+  }
+  n := copy(p, r.buf)
+  r.buf = r.buf[n:]
+  return n, nil
+}
+
+// TestServeProtocolRetriesSessionCreation verifies a project that is invalid
+// at startup answers with an error and recovers on a later request.
+//
+// The MCP server starts the native process lazily, so the first request may
+// hit a broken tsconfig. Failing session creation must stay per-request: the
+// server keeps running, and once the config is fixed the same process builds
+// the session and serves the initial dump.
+//
+//  1. Request a snapshot while tsconfig.json is invalid; assert an error.
+//  2. Fix the config between requests, request again.
+//  3. Assert the second response is a normal initial snapshot.
+func TestServeProtocolRetriesSessionCreation(t *testing.T) {
+  root := t.TempDir()
+  config := filepath.Join(root, "tsconfig.json")
+  writeGraphFile(t, config, "{ invalid")
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "export class Recovered {}\n")
+
+  valid := `{"compilerOptions":{"target":"ES2022","module":"commonjs","strict":true},"include":["src"]}`
+  input := &stepReader{steps: []func() []byte{
+    func() []byte { return []byte("{\"id\":1}\n") },
+    func() []byte {
+      if err := os.WriteFile(config, []byte(valid), 0o644); err != nil {
+        t.Fatal(err)
+      }
+      return []byte("{\"id\":2}\n")
+    },
+  }}
+  var output bytes.Buffer
+
+  if code := serveSnapshots(input, &output, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("serveSnapshots exited %d", code)
+  }
+  decoder := json.NewDecoder(&output)
+  var failed serveResponse
+  var recovered serveResponse
+  if err := decoder.Decode(&failed); err != nil {
+    t.Fatal(err)
+  }
+  if err := decoder.Decode(&recovered); err != nil {
+    t.Fatal(err)
+  }
+  if failed.ID != 1 || failed.Error == "" || failed.Dump != nil || failed.Changed {
+    t.Fatalf("invalid project response: %#v", failed)
+  }
+  if recovered.ID != 2 || recovered.Mode != "initial" || !recovered.Changed || recovered.Dump == nil || recovered.Error != "" {
+    t.Fatalf("recovered response: %#v", recovered)
+  }
+  if !hasDumpNode(*recovered.Dump, "Recovered") {
+    t.Fatalf("recovered dump omitted the declaration: %#v", recovered.Dump.Nodes)
+  }
+}

package/cmd/ttscgraph/serve_protocol_reuses_session_test.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+// TestServeProtocolReusesSession verifies multiple NDJSON requests share one
+// compiler session and unchanged responses omit the full dump.
+func TestServeProtocolReusesSession(t *testing.T) {
+  root := graphSessionFixture(t)
+  input := strings.NewReader("{\"id\":1}\n{\"id\":2}\n")
+  var output bytes.Buffer
+
+  if code := serveSnapshots(input, &output, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("serveSnapshots exited %d", code)
+  }
+  decoder := json.NewDecoder(&output)
+  var initial serveResponse
+  var unchanged serveResponse
+  if err := decoder.Decode(&initial); err != nil {
+    t.Fatal(err)
+  }
+  if err := decoder.Decode(&unchanged); err != nil {
+    t.Fatal(err)
+  }
+  if initial.ID != 1 || initial.Mode != "initial" || !initial.Changed || initial.Dump == nil {
+    t.Fatalf("initial response: %#v", initial)
+  }
+  if unchanged.ID != 2 || unchanged.Mode != "unchanged" || unchanged.Changed || unchanged.Dump != nil {
+    t.Fatalf("unchanged response: %#v", unchanged)
+  }
+}

package/cmd/ttscgraph/serve_session_applies_source_edit_incrementally_test.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
+)
+
+// TestServeSessionAppliesSourceEditIncrementally verifies a content-only source
+// edit updates the graph through the resident tsgo Program.
+//
+// A declaration rename changes graph nodes but not imports, so UpdateProgram can
+// reuse every unchanged AST. The new dump must expose the replacement symbol
+// and remove the old one without reopening the project.
+//
+// 1. Build the initial graph containing `BeforeEdit`.
+// 2. Replace it with `AfterEdit` in the same source file.
+// 3. Assert incremental mode and an exact post-edit node set.
+func TestServeSessionAppliesSourceEditIncrementally(t *testing.T) {
+  root := graphSessionFixture(t)
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+
+  file := filepath.Join(root, "src", "index.ts")
+  if err := os.WriteFile(file, []byte("export class AfterEdit {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "incremental" || !changed {
+    t.Fatalf("edited snapshot = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+  if !hasDumpNode(*dump, "AfterEdit") || hasDumpNode(*dump, "BeforeEdit") {
+    t.Fatalf("incremental dump kept stale nodes: %#v", dump.Nodes)
+  }
+}
+
+func hasDumpNode(dump graph.Dump, name string) bool {
+  for _, node := range dump.Nodes {
+    if node.Name == name {
+      return true
+    }
+  }
+  return false
+}

package/cmd/ttscgraph/serve_session_fails_closed_on_deleted_config_test.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionFailsClosedOnDeletedConfig verifies removing the project
+// config fails the snapshot without poisoning the resident session.
+//
+// The boundary twin of the invalid-config case: deletion takes the
+// hashesChanged ErrNotExist branch and its forced reload fails at session
+// construction rather than config parsing. A byte-identical restore must then
+// report unchanged — the resident graph still matches the disk exactly — and
+// the compiler session must keep serving incremental edits, proving the
+// failed reload episode left no partial state behind.
+//
+//  1. Build a valid initial graph, then delete tsconfig.json.
+//  2. Assert the snapshot fails with no dump.
+//  3. Restore the identical config and assert the snapshot is unchanged.
+//  4. Edit the source and assert an incremental refresh still works.
+func TestServeSessionFailsClosedOnDeletedConfig(t *testing.T) {
+  root := graphSessionFixture(t)
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+
+  config := filepath.Join(root, "tsconfig.json")
+  saved, err := os.ReadFile(config)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if err := os.Remove(config); err != nil {
+    t.Fatal(err)
+  }
+  dump, _, changed, err := session.Snapshot()
+  if err == nil || dump != nil || changed {
+    t.Fatalf("deleted config must fail closed: dump:%v changed:%v err:%v", dump != nil, changed, err)
+  }
+
+  if err := os.WriteFile(config, saved, 0o644); err != nil {
+    t.Fatal(err)
+  }
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != "unchanged" || changed {
+    t.Fatalf("identical restored config must be unchanged: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  if err := os.WriteFile(filepath.Join(root, "src", "index.ts"), []byte("export class AfterEdit {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  dump, mode, changed, err = session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "incremental" || !changed || !hasDumpNode(*dump, "AfterEdit") {
+    t.Fatalf("session did not survive the failed reload: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_fails_closed_on_invalid_config_test.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionFailsClosedOnInvalidConfig verifies a broken project config
+// never falls back to the last valid graph and recovers after the config is fixed.
+//
+// Returning stale compiler facts is worse than returning an MCP error. A config
+// parse failure must therefore suppress the dump while preserving enough
+// session state to retry the reload on the next request.
+//
+// 1. Build a valid initial graph, then replace tsconfig.json with invalid JSON.
+// 2. Assert snapshot fails with no dump instead of serving the cached graph.
+// 3. Restore a valid config and assert the next request reloads successfully.
+func TestServeSessionFailsClosedOnInvalidConfig(t *testing.T) {
+  root := graphSessionFixture(t)
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+
+  config := filepath.Join(root, "tsconfig.json")
+  if err := os.WriteFile(config, []byte("{ invalid"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  dump, _, changed, err := session.Snapshot()
+  if err == nil || dump != nil || changed {
+    t.Fatalf("invalid config must fail closed: dump:%v changed:%v err:%v", dump != nil, changed, err)
+  }
+
+  valid := `{"compilerOptions":{"target":"ES2022","module":"commonjs","strict":true},"include":["src"]}`
+  if err := os.WriteFile(config, []byte(valid), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "reload" || !changed || !hasDumpNode(*dump, "BeforeEdit") {
+    t.Fatalf("fixed config did not recover: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_keeps_missing_literal_root_unchanged_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionKeepsMissingLiteralRootUnchanged verifies a permanently
+// absent `files` entry does not churn the session.
+//
+// The negative twin of the created-literal-root reload: tracking a missing
+// root as a freshness input must record a stable absent state. If the stored
+// parse-time root set and the reloaded one disagreed about missing literal
+// entries, or the absent state flapped, every snapshot would degrade into a
+// full reload and silently erase the resident session's entire benefit.
+//
+//  1. Open a session whose tsconfig lists absent `src/generated.ts` in files.
+//  2. Take repeated snapshots without touching the project.
+//  3. Assert each one reports unchanged with no replacement dump.
+func TestServeSessionKeepsMissingLiteralRootUnchanged(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs" },
+  "files": ["src/index.ts", "src/generated.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "export class Present {}\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)
+  }
+
+  for i := 0; i < 2; i++ {
+    dump, mode, changed, err := session.Snapshot()
+    if err != nil {
+      t.Fatal(err)
+    }
+    if dump != nil || mode != "unchanged" || changed {
+      t.Fatalf("iteration %d: missing literal root churned = dump:%v mode:%q changed:%v", i, dump != nil, mode, changed)
+    }
+  }
+}

package/cmd/ttscgraph/serve_session_rebuilds_import_graph_change_test.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionRebuildsImportGraphChange verifies an edited import set uses
+// tsgo's safe rebuild path instead of claiming structural reuse.
+//
+// UpdateProgram can replace one AST only while its module references are
+// unchanged. Adding an import must rebuild the Program, refresh the Checker, and
+// emit the newly-resolved call edge in the same resident native process.
+//
+// 1. Start with two exported functions and no edge between them.
+// 2. Edit the first file to import and call the second.
+// 3. Assert rebuild mode and a calls edge from `main` to `helper`.
+func TestServeSessionRebuildsImportGraphChange(t *testing.T) {
+  root := graphSessionFixture(t)
+  helper := filepath.Join(root, "src", "helper.ts")
+  if err := os.WriteFile(helper, []byte("export function helper(): void {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+
+  index := filepath.Join(root, "src", "index.ts")
+  content := "import { helper } from './helper';\nexport function main(): void { helper(); }\n"
+  if err := os.WriteFile(index, []byte(content), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "rebuild" || !changed {
+    t.Fatalf("import edit = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+  mainID, helperID := "", ""
+  for _, node := range dump.Nodes {
+    if node.Name == "main" {
+      mainID = node.ID
+    } else if node.Name == "helper" {
+      helperID = node.ID
+    }
+  }
+  for _, edge := range dump.Edges {
+    if edge.From == mainID && edge.To == helperID && edge.Kind == "calls" {
+      return
+    }
+  }
+  t.Fatalf("rebuilt graph omitted main -> helper call: nodes=%#v edges=%#v", dump.Nodes, dump.Edges)
+}

package/cmd/ttscgraph/serve_session_reloads_created_literal_root_test.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsCreatedLiteralRoot verifies a `files`-listed root
+// that does not exist yet joins the graph once it is created.
+//
+// A literal `files` entry survives a root-set reload whether or not the file
+// exists, so the root comparison never flips for it, and a file absent from
+// the program has no source hash and no unresolved-import candidate. The
+// session must track missing literal roots as freshness inputs of their own.
+//
+//  1. Open a session whose tsconfig lists absent `src/generated.ts` in files.
+//  2. Create that file without touching any other project input.
+//  3. Assert the next snapshot reloads and exposes the new declaration.
+func TestServeSessionReloadsCreatedLiteralRoot(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs" },
+  "files": ["src/index.ts", "src/generated.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "export class Present {}\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, "src", "generated.ts"), "export class Generated {}\n")
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "reload" || !changed || !hasDumpNode(*dump, "Generated") {
+    t.Fatalf("created files-listed root was not reloaded: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_extended_config_change_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsExtendedConfigChange verifies every config in an
+// extends chain participates in snapshot freshness.
+//
+// Watching only the requested tsconfig misses compiler-option changes inherited
+// from a base file. The session records all parsed extended source files and
+// must full-reload before answering after any one changes.
+//
+// 1. Create a project whose tsconfig extends `base.json`.
+// 2. Build once, then change a compiler option only in the base config.
+// 3. Assert the next snapshot reports a full reload.
+func TestServeSessionReloadsExtendedConfigChange(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "base.json"), `{"compilerOptions":{"strict":true,"target":"ES2022"}}`)
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{"extends":"./base.json","include":["src"]}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "export class Value {}\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)
+  }
+
+  base := filepath.Join(root, "base.json")
+  if err := os.WriteFile(base, []byte(`{"compilerOptions":{"strict":false,"target":"ES2022"}}`), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "reload" || !changed {
+    t.Fatalf("extended config edit = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_conditional_export_test.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedConditionalExport verifies conditional
+// exports objects and array fallbacks contribute resolution candidates.
+//
+// Real packages rarely map a subpath straight to one string: `exports`
+// commonly nests condition objects (`types`, `default`) and array fallbacks.
+// Every leaf target must be tracked, or a package shipping its compiled
+// output later stays invisible to the resident graph.
+//
+//  1. Import a package subpath whose exports leaf targets do not exist yet.
+//  2. Create the `types` condition's declaration target.
+//  3. Assert the next snapshot reports a full reload.
+func TestServeSessionReloadsNewlyResolvedConditionalExport(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs" },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "import { feature } from 'fixture-package/feature';\nexport function main(): void { feature(); }\n")
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "package.json"), `{
+  "name": "fixture-package",
+  "exports": {
+    "./feature": {
+      "types": "./dist/feature.d.ts",
+      "default": ["./dist/feature.js"]
+    }
+  }
+}`)
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+
+  target := filepath.Join(root, "node_modules", "fixture-package", "dist", "feature.d.ts")
+  if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(target, []byte("export declare function feature(): void;\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "reload" || !changed {
+    t.Fatalf("new conditional export target = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_config_types_test.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedConfigTypes verifies compilerOptions
+// `types` entries participate in freshness without any source-level syntax.
+//
+// A `types` package is requested by the config alone, so no triple-slash
+// directive or import exists to contribute resolution candidates. Generated
+// typeRoots packages appear without touching package.json or the lockfile,
+// which would leave the graph permanently blind to them.
+//
+//  1. Open a session whose config lists absent types package `fixture-types`.
+//  2. Create the package under the configured typeRoots directory.
+//  3. Assert the next snapshot reports a full reload.
+func TestServeSessionReloadsNewlyResolvedConfigTypes(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "typeRoots": ["./types"], "types": ["fixture-types"] },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "export const value = 1;\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, "types", "fixture-types", "index.d.ts"), "interface FixtureType { id: number }\n")
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "reload" || !changed {
+    t.Fatalf("new config types package = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}