ttsc 0.18.2 → 0.18.4

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_excluded_import_test.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedExcludedImport verifies a previously
+// missing relative import becomes visible even when the new file is not a
+// tsconfig root.
+//
+// Comparing only parsed root file names misses this transition: `files` stays
+// unchanged while module resolution changes from unresolved to resolved. The
+// session snapshots concrete resolution candidates and reloads when one appears.
+//
+// 1. Compile one root that imports missing, excluded `generated.ts`.
+// 2. Create that module without changing the importer or tsconfig roots.
+// 3. Assert reload mode and the newly-resolved declaration and call edge.
+func TestServeSessionReloadsNewlyResolvedExcludedImport(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "import { generated } from './generated';\nexport function main(): void { generated(); }\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)
+  }
+
+  generated := filepath.Join(root, "src", "generated.ts")
+  if err := os.WriteFile(generated, []byte("export function generated(): 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 || !hasDumpNode(*dump, "generated") {
+    t.Fatalf("new resolution = dump:%v mode:%q changed:%v nodes:%#v", dump != nil, mode, changed, dump)
+  }
+  mainID, generatedID := "", ""
+  for _, node := range dump.Nodes {
+    if node.Name == "main" {
+      mainID = node.ID
+    } else if node.Name == "generated" {
+      generatedID = node.ID
+    }
+  }
+  for _, edge := range dump.Edges {
+    if edge.From == mainID && edge.To == generatedID && edge.Kind == "calls" {
+      return
+    }
+  }
+  t.Fatalf("reloaded graph omitted main -> generated call: %#v", dump.Edges)
+}

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_package_export_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedPackageExport verifies an exports target
+// appearing under an existing package triggers module-resolution reload.
+func TestServeSessionReloadsNewlyResolvedPackageExport(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": "./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.ts")
+  if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(target, []byte("export 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 package export target = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_package_import_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedPackageImport verifies wildcard imports
+// targets are tracked with the wildcard text matched from the package key.
+func TestServeSessionReloadsNewlyResolvedPackageImport(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "package.json"), `{
+  "name": "fixture-project",
+  "imports": { "#generated/*": "./generated/*.js" }
+}`)
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "nodenext", "moduleResolution": "nodenext" },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "import { generated } from '#generated/value';\nexport function main(): void { generated(); }\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)
+  }
+
+  target := filepath.Join(root, "generated", "value.ts")
+  if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(target, []byte("export function generated(): 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 package imports target = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_path_alias_test.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedPathAlias verifies a missing paths target
+// is tracked even when it is excluded from the tsconfig root set.
+func TestServeSessionReloadsNewlyResolvedPathAlias(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "baseUrl": ".",
+    "paths": { "@generated/*": ["generated/*"] }
+  },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "import { generated } from '@generated/value';\nexport function main(): void { generated(); }\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)
+  }
+
+  target := filepath.Join(root, "generated", "value.ts")
+  if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(target, []byte("export function generated(): 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 || !hasDumpNode(*dump, "generated") {
+    t.Fatalf("new paths target = dump:%v mode:%q changed:%v nodes:%#v", dump != nil, mode, changed, dump)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_reference_path_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedReferencePath verifies triple-slash path
+// directives participate in freshness even though they are not AST statements.
+func TestServeSessionReloadsNewlyResolvedReferencePath(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"), "/// <reference path=\"../generated/types.d.ts\" />\nexport const value: Generated = { id: 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)
+  }
+
+  target := filepath.Join(root, "generated", "types.d.ts")
+  if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(target, []byte("interface Generated { id: number }\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 reference path = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_root_dirs_target_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedRootDirsTarget verifies virtual relative
+// paths across rootDirs participate in module-resolution freshness.
+func TestServeSessionReloadsNewlyResolvedRootDirsTarget(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "rootDirs": ["src", "generated"]
+  },
+  "files": ["src/views/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "views", "index.ts"), "import { template } from './template';\nexport function render(): void { template(); }\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)
+  }
+
+  target := filepath.Join(root, "generated", "views", "template.ts")
+  if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(target, []byte("export function template(): 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 || !hasDumpNode(*dump, "template") {
+    t.Fatalf("new rootDirs target = dump:%v mode:%q changed:%v nodes:%#v", dump != nil, mode, changed, dump)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_newly_resolved_type_reference_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsNewlyResolvedTypeReference verifies triple-slash type
+// directives honor configured typeRoots when a missing package appears.
+func TestServeSessionReloadsNewlyResolvedTypeReference(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "typeRoots": ["./types"] },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "/// <reference types=\"fixture-types\" />\nexport const value: FixtureType = { id: 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)
+  }
+
+  target := filepath.Join(root, "types", "fixture-types", "index.d.ts")
+  if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(target, []byte("interface FixtureType { id: number }\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 type reference = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_root_file_set_test.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsRootFileSet verifies include-glob additions and
+// deletions replace the compiler session rather than leaving stale roots.
+//
+// A one-file UpdateProgram cannot add or remove config roots. The session must
+// re-evaluate the tsconfig file set before source hashing and reload whenever
+// that set changes.
+//
+// 1. Add `AddedRoot` under an included directory and assert reload plus presence.
+// 2. Delete the original `BeforeEdit` root.
+// 3. Assert another reload removes the deleted declaration.
+func TestServeSessionReloadsRootFileSet(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)
+  }
+
+  added := filepath.Join(root, "src", "added.ts")
+  if err := os.WriteFile(added, []byte("export class AddedRoot {}\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 || !hasDumpNode(*dump, "AddedRoot") {
+    t.Fatalf("added root was not reloaded: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  if err := os.Remove(filepath.Join(root, "src", "index.ts")); 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("deleted root remained in graph: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_source_deleted_during_load_test.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestServeSessionReloadsSourceDeletedDuringLoad verifies a program source
+// that vanishes between compiler load and state capture is still detected.
+//
+// captureState hashes only sources it can read back from disk, so silently
+// skipping a just-deleted file would drop it from every later freshness check:
+// no root change, no source hash, no resolution candidate. The session must
+// record the resident text instead so the next snapshot observes the deletion
+// and reloads rather than serving the vanished declarations forever.
+//
+//  1. Load a session whose root imports `helper.ts`.
+//  2. Delete `helper.ts` before capturing the freshness state.
+//  3. Assert the next snapshot reloads and drops the deleted declaration.
+func TestServeSessionReloadsSourceDeletedDuringLoad(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 { helper } from './helper';\nexport function main(): void { helper(); }\n")
+  writeGraphFile(t, filepath.Join(root, "src", "helper.ts"), "export function helper(): void {}\n")
+
+  compiler, diags, err := driver.NewSession(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if compiler == nil {
+    t.Fatalf("NewSession returned nil session (diagnostics: %v)", diags)
+  }
+  if err := os.Remove(filepath.Join(root, "src", "helper.ts")); err != nil {
+    t.Fatal(err)
+  }
+  session := &graphSession{
+    cwd:         root,
+    tsconfig:    "tsconfig.json",
+    compiler:    compiler,
+    initialized: true,
+  }
+  defer session.Close()
+  if err := session.captureState(); 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, "helper") {
+    t.Fatalf("deleted-during-load source survived: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_transitive_project_reference_test.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsTransitiveProjectReference verifies config and root
+// freshness traverses the complete project-reference graph, not only the
+// root config's direct references.
+func TestServeSessionReloadsTransitiveProjectReference(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "files": ["src/index.ts"],
+  "references": [{ "path": "./middle" }]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "export const root = 1;\n")
+  writeGraphFile(t, filepath.Join(root, "middle", "tsconfig.json"), `{
+  "compilerOptions": { "composite": true },
+  "files": ["src/index.ts"],
+  "references": [{ "path": "../leaf" }]
+}`)
+  writeGraphFile(t, filepath.Join(root, "middle", "src", "index.ts"), "export const middle = 1;\n")
+  writeGraphFile(t, filepath.Join(root, "leaf", "tsconfig.json"), `{
+  "compilerOptions": { "composite": true },
+  "include": ["src"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "leaf", "src", "index.ts"), "export const leaf = 1;\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  leafConfig := filepath.ToSlash(filepath.Join(root, "leaf", "tsconfig.json"))
+  if _, ok := session.configHashes[leafConfig]; !ok {
+    t.Fatalf("transitive project config was not tracked: %s; got %#v", leafConfig, session.configHashes)
+  }
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+
+  added := filepath.Join(root, "leaf", "src", "added.ts")
+  if err := os.WriteFile(added, []byte("export const added = 1;\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("transitive root addition = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_when_program_plugin_linked_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+type serveProgramPluginProbe struct{}
+
+func (serveProgramPluginProbe) ApplyProgram(*driver.Program, driver.PluginContext) error {
+  return nil
+}
+
+// TestServeSessionReloadsWhenProgramPluginLinked verifies a project with an
+// active linked ProgramPlugin never takes the incremental source path.
+//
+// ProgramPlugin hooks mutate parsed ASTs in place and run exactly once per
+// Program, so an incremental source replacement would leave the new AST
+// without the plugin's mutations while the rest of the graph still carries
+// them. A content-only edit must therefore rebuild through a full reload.
+//
+//  1. Register a linked ProgramPlugin and open a graph session.
+//  2. Apply a content-only edit that would otherwise refresh incrementally.
+//  3. Assert the snapshot reports a full reload with the post-edit node.
+func TestServeSessionReloadsWhenProgramPluginLinked(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, `[{"name":"probe","stage":"transform"}]`)
+  driver.RegisterPlugin(serveProgramPluginProbe{})
+
+  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 != "reload" || !changed || !hasDumpNode(*dump, "AfterEdit") {
+    t.Fatalf("program-plugin edit = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reuses_unchanged_preamble_source_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestServeSessionReusesUnchangedPreambleSource verifies injected compiler text
+// is compared against the corresponding raw disk source, not mistaken for an
+// edit on every snapshot.
+func TestServeSessionReusesUnchangedPreambleSource(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{"compilerOptions":{"strict":true},"files":["index.ts"]}`)
+  writeGraphFile(t, filepath.Join(root, "index.ts"), "export const value = 1;\n")
+
+  compiler, diags, err := driver.NewSession(root, "tsconfig.json", driver.LoadProgramOptions{
+    SourcePreamble: "declare const injected: number;\n",
+  })
+  if err != nil {
+    t.Fatal(err)
+  }
+  if compiler == nil {
+    t.Fatalf("NewSession returned nil session (diagnostics: %v)", diags)
+  }
+  session := &graphSession{
+    cwd:         root,
+    tsconfig:    "tsconfig.json",
+    compiler:    compiler,
+    initialized: true,
+  }
+  defer session.Close()
+  if err := session.captureState(); 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("unchanged preamble source = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reuses_unchanged_snapshot_test.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReusesUnchangedSnapshot verifies repeated graph requests do
+// no graph rebuild when every project input is byte-identical.
+//
+// This is the hot MCP path. The native session still checks its config, root
+// file set, and resident source hashes, but it must omit the dump so the Node
+// server can retain its indexed maps without parsing or synthesizing them again.
+//
+// 1. Open a one-file graph session and request its initial dump.
+// 2. Request another snapshot without touching the project.
+// 3. Assert the second response is unchanged and carries no replacement dump.
+func TestServeSessionReusesUnchangedSnapshot(t *testing.T) {
+  root := graphSessionFixture(t)
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+
+  first, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if first == nil || mode != "initial" || !changed {
+    t.Fatalf("initial snapshot = dump:%v mode:%q changed:%v", first != nil, mode, changed)
+  }
+
+  second, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if second != nil || mode != "unchanged" || changed {
+    t.Fatalf("unchanged snapshot = dump:%v mode:%q changed:%v", second != nil, mode, changed)
+  }
+}
+
+func graphSessionFixture(t *testing.T) string {
+  t.Helper()
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "export class BeforeEdit {}\n")
+  return root
+}