ttsc 0.19.2 → 0.20.0

package/cmd/ttscgraph/serve_session_keeps_inactive_conditional_export_unchanged_test.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionKeepsInactiveConditionalExportUnchanged verifies a
+// condition the active TypeScript-Go lookup cannot select is not a graph
+// freshness input.
+//
+// An inactive branch can be present ahead of the active `types` and `default`
+// branches in package.json, but creating that target must not reload a
+// resident ESM session. Creating the missing active `types` target still must.
+func TestServeSessionKeepsInactiveConditionalExportUnchanged(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 '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": {
+      "browser": "./dist/browser.js",
+      "types": "./dist/types.d.ts",
+      "default": "./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", "dist", "browser.js"), "export function winner() {}\nexport function browserOnly() {}\n")
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != serveModeUnchanged || changed {
+    t.Fatalf("inactive browser condition = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "types.d.ts"), "export declare function winner(): void;\nexport declare function typesWinner(): void;\n")
+  dump, mode, changed, err = session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != serveModeReload || !changed {
+    t.Fatalf("active types condition = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_keeps_lower_priority_module_candidate_unchanged_test.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionKeepsLowerPriorityModuleCandidateUnchanged verifies a
+// resident session does not reload when a candidate after its selected target
+// appears.
+//
+// Directory index probes are lower priority than every direct-file probe. An
+// interleaved candidate list would turn the creation of an irrelevant index
+// file into a full program reload and erase the bounded-freshness guarantee.
+//
+//  1. Load an extensionless commonjs import that resolves directly to value.js.
+//  2. Create only lower-priority value/index.ts and value.mts candidates.
+//  3. Assert the resident session remains unchanged, then create value.ts and
+//     assert the strictly higher-priority candidate does reload it.
+func TestServeSessionKeepsLowerPriorityModuleCandidateUnchanged(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "allowJs": true, "module": "commonjs", "target": "ES2022" },
+  "files": ["src/main.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { winner } from './value';\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", "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("lower-priority index = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  writeGraphFile(t, filepath.Join(root, "src", "value.mts"), "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("commonjs-lower-priority .mts = 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("higher-priority .ts = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_keeps_lower_priority_paths_pattern_unchanged_test.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionKeepsLowerPriorityPathsPatternUnchanged verifies only the
+// most-specific TypeScript-Go paths pattern contributes freshness candidates.
+//
+// `@/special/*` outranks `@/*`; a file under the broad substitution never
+// participates in this lookup, while a missing .ts sibling of the selected
+// specific substitution does.
+func TestServeSessionKeepsLowerPriorityPathsPatternUnchanged(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "allowJs": true,
+    "baseUrl": ".",
+    "module": "commonjs",
+    "paths": {
+      "@/*": ["broad/*"],
+      "@/special/*": ["specific/*"]
+    },
+    "target": "ES2022"
+  },
+  "files": ["src/main.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { winner } from '@/special/value';\nexport function main(): void { winner(); }\n")
+  writeGraphFile(t, filepath.Join(root, "specific", "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)
+  }
+
+  writeGraphFile(t, filepath.Join(root, "broad", "special", "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("broad paths pattern = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  writeGraphFile(t, filepath.Join(root, "specific", "value.ts"), "export function winner(): void {}\nexport function specificPathsWinner(): void {}\n")
+  dump, mode, changed, err = session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != serveModeReload || !changed || !hasDumpNode(*dump, "specificPathsWinner") {
+    t.Fatalf("specific paths pattern = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_keeps_nonlongest_root_dirs_candidate_unchanged_test.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionKeepsNonLongestRootDirsCandidateUnchanged verifies rootDirs
+// starts from TypeScript-Go's longest matching source root.
+//
+// The containing source lies under both src and src/generated. Only the
+// longest root makes out/views/template a peer candidate; out/generated/views
+// comes from the shorter root and is never tried by this resolution.
+func TestServeSessionKeepsNonLongestRootDirsCandidateUnchanged(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "allowJs": true,
+    "module": "commonjs",
+    "rootDirs": ["src", "src/generated", "out"],
+    "target": "ES2022"
+  },
+  "files": ["src/generated/views/main.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "generated", "views", "main.ts"), "import { winner } from './template';\nexport function main(): void { winner(); }\n")
+  writeGraphFile(t, filepath.Join(root, "out", "views", "template.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, "out", "generated", "views", "template.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("non-longest rootDirs candidate = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  writeGraphFile(t, filepath.Join(root, "src", "views", "template.ts"), "export function winner(): void {}\nexport function rootDirsWinner(): void {}\n")
+  dump, mode, changed, err = session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != serveModeReload || !changed || !hasDumpNode(*dump, "rootDirsWinner") {
+    t.Fatalf("longest-root peer candidate = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_commonjs_package_entry_for_esm_test.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsCommonJSPackageEntryForESM verifies an ESM importer
+// preserves the CommonJS fallback rules of a package's extensionless main.
+//
+// The importing source is ESM, but TypeScript-Go temporarily uses CommonJS
+// lookup for a package without `type: module`. A missing main.ts therefore
+// precedes main.js and must invalidate the resident session when it appears.
+func TestServeSessionReloadsCommonJSPackageEntryForESM(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 'fixture-package';\nexport function main(): void { winner(); }\n")
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "package.json"), `{
+  "name": "fixture-package",
+  "main": "./dist/main"
+}`)
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "main.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", "dist", "main.ts"), "export function winner(): void {}\nexport function packageEntryWinner(): void {}\n")
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != serveModeReload || !changed || !hasDumpNode(*dump, "packageEntryWinner") {
+    t.Fatalf("CommonJS package main.ts = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_module_suffix_candidate_test.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsModuleSuffixCandidate verifies a configured module
+// suffix is considered before the unsuffixed extension candidate.
+func TestServeSessionReloadsModuleSuffixCandidate(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "allowJs": true,
+    "module": "commonjs",
+    "moduleSuffixes": [".native", ""],
+    "target": "ES2022"
+  },
+  "files": ["src/main.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { winner } from './value';\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)
+  }
+
+  writeGraphFile(t, filepath.Join(root, "src", "value.native.ts"), "export function winner(): void {}\nexport function nativeWinner(): void {}\n")
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != serveModeReload || !changed || !hasDumpNode(*dump, "nativeWinner") {
+    t.Fatalf("module-suffix candidate = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_superseding_module_candidates_test.go

@@ -0,0 +1,216 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionReloadsSupersedingModuleCandidates verifies a resident
+// session reloads when an unchanged specifier gains a missing candidate that
+// outranks the file TypeScript-Go selected for the first snapshot.
+//
+// A resident session cannot rely on a changed importer or tsconfig to notice a
+// resolution precedence change. Each case pins a distinct resolver family while
+// preserving both files between observations.
+//
+//  1. Load a project whose specifier resolves to the lower-priority target.
+//  2. Create only the absent target that precedes it in that resolver's search.
+//  3. Assert the resident snapshot reloads and exposes the new target when one
+//     carries a distinguishing declaration.
+func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
+  cases := []struct {
+    name  string
+    setup func(*testing.T, string) string
+    add   func(*testing.T, string)
+  }{
+    {
+      name: "relative_extension",
+      setup: func(t *testing.T, root string) string {
+        writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "allowJs": true, "module": "commonjs", "target": "ES2022" },
+  "files": ["src/main.ts"]
+}`)
+        writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { winner } from './value';\nexport function main(): void { winner(); }\n")
+        writeGraphFile(t, filepath.Join(root, "src", "value.js"), "export function winner() {}\n")
+        return "typescriptWinner"
+      },
+      add: func(t *testing.T, root string) {
+        writeGraphFile(t, filepath.Join(root, "src", "value.ts"), "export function winner(): void {}\nexport function typescriptWinner(): void {}\n")
+      },
+    },
+    {
+      name: "ordered_paths",
+      setup: func(t *testing.T, root string) string {
+        writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "commonjs",
+    "paths": { "@generated/*": ["first/*", "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")
+        return "firstPathsWinner"
+      },
+      add: func(t *testing.T, root string) {
+        writeGraphFile(t, filepath.Join(root, "first", "value.ts"), "export function winner(): void {}\nexport function firstPathsWinner(): void {}\n")
+      },
+    },
+    {
+      name: "root_dirs",
+      setup: func(t *testing.T, root string) string {
+        writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "module": "commonjs",
+    "rootDirs": ["src", "generated"],
+    "target": "ES2022"
+  },
+  "files": ["src/views/main.ts"]
+}`)
+        writeGraphFile(t, filepath.Join(root, "src", "views", "main.ts"), "import { winner } from './template';\nexport function main(): void { winner(); }\n")
+        writeGraphFile(t, filepath.Join(root, "generated", "views", "template.ts"), "export function winner(): void {}\n")
+        return "rootDirsWinner"
+      },
+      add: func(t *testing.T, root string) {
+        writeGraphFile(t, filepath.Join(root, "src", "views", "template.ts"), "export function winner(): void {}\nexport function rootDirsWinner(): void {}\n")
+      },
+    },
+    {
+      name: "nearer_node_modules",
+      setup: func(t *testing.T, root string) string {
+        writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "allowJs": true, "module": "commonjs", "target": "ES2022" },
+  "files": ["src/deep/main.ts"]
+}`)
+        writeGraphFile(t, filepath.Join(root, "src", "deep", "main.ts"), "import { winner } from 'fixture-package';\nexport function main(): void { winner(); }\n")
+        writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "index.js"), "export function winner() {}\n")
+        return "nearerNodeModulesWinner"
+      },
+      add: func(t *testing.T, root string) {
+        writeGraphFile(t, filepath.Join(root, "src", "node_modules", "fixture-package", "index.ts"), "export function winner(): void {}\nexport function nearerNodeModulesWinner(): void {}\n")
+      },
+    },
+    {
+      name: "package_exports",
+      setup: func(t *testing.T, root string) string {
+        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")
+        return ""
+      },
+      add: func(t *testing.T, root string) {
+        writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "first.js"), "export function winner() {}\nexport function exportsWinner() {}\n")
+      },
+    },
+    {
+      name: "conditional_package_exports",
+      setup: func(t *testing.T, root string) string {
+        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": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/fallback.js"
+    }
+  }
+}`)
+        writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "fallback.js"), "export function winner() {}\n")
+        return ""
+      },
+      add: func(t *testing.T, root string) {
+        writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "types.d.ts"), "export declare function winner(): void;\n")
+      },
+    },
+    {
+      name: "conditional_package_imports",
+      setup: func(t *testing.T, root string) string {
+        writeGraphFile(t, filepath.Join(root, "package.json"), `{
+  "name": "fixture-project",
+  "imports": {
+    "#feature": {
+      "types": "./generated/types.d.ts",
+      "default": "./generated/fallback.js"
+    }
+  }
+}`)
+        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 '#feature';\nexport function main(): void { winner(); }\n")
+        writeGraphFile(t, filepath.Join(root, "generated", "fallback.js"), "export function winner() {}\n")
+        return ""
+      },
+      add: func(t *testing.T, root string) {
+        writeGraphFile(t, filepath.Join(root, "generated", "types.d.ts"), "export declare function winner(): void;\n")
+      },
+    },
+    {
+      name: "file_over_directory_index",
+      setup: func(t *testing.T, root string) string {
+        writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "allowJs": true, "module": "commonjs", "target": "ES2022" },
+  "files": ["src/main.ts"]
+}`)
+        writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { winner } from './feature';\nexport function main(): void { winner(); }\n")
+        writeGraphFile(t, filepath.Join(root, "src", "feature", "index.js"), "export function winner() {}\n")
+        return "fileWinner"
+      },
+      add: func(t *testing.T, root string) {
+        writeGraphFile(t, filepath.Join(root, "src", "feature.js"), "export function winner() {}\nexport function fileWinner() {}\n")
+      },
+    },
+  }
+  for _, test := range cases {
+    t.Run(test.name, func(t *testing.T) {
+      root := t.TempDir()
+      want := test.setup(t, root)
+      session, err := newGraphSession(root, "tsconfig.json")
+      if err != nil {
+        t.Fatal(err)
+      }
+      defer session.Close()
+      if _, _, _, err := session.Snapshot(); err != nil {
+        t.Fatal(err)
+      }
+
+      test.add(t, root)
+      dump, mode, changed, err := session.Snapshot()
+      if err != nil {
+        t.Fatal(err)
+      }
+      if dump == nil || mode != serveModeReload || !changed || (want != "" && !hasDumpNode(*dump, want)) {
+        t.Fatalf("superseding candidate = dump:%v mode:%q changed:%v want-node:%q", dump != nil, mode, changed, want)
+      }
+    })
+  }
+}

package/cmd/ttscgraph/serve_session_retries_failed_dump_test.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestServeSessionKeepsChangeDetectionLiveAfterInitialDumpError verifies a
+// rejected first dump still advances the session into its change-detection
+// state. The invalid relative cwd is a deterministic path-mapper failure; once
+// corrected, the same captured generation is retried and can become the first
+// published snapshot.
+func TestServeSessionKeepsChangeDetectionLiveAfterInitialDumpError(t *testing.T) {
+  root := graphSessionFixture(t)
+  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)
+  }
+  session := &graphSession{
+    cwd:      root,
+    tsconfig: "tsconfig.json",
+    compiler: compiler,
+  }
+  defer session.Close()
+  if err := session.captureState(); err != nil {
+    t.Fatal(err)
+  }
+  session.cwd = "relative-project"
+
+  dump, _, changed, err := session.Snapshot()
+  if err == nil || !strings.Contains(err.Error(), "project root") {
+    t.Fatalf("initial dump error = %v, want absolute-root rejection", err)
+  }
+  if dump != nil || changed || !session.initialized || session.pendingDumpMode != serveModeInitial {
+    t.Fatalf(
+      "failed initial state = dump:%v changed:%v initialized:%v pending:%q",
+      dump != nil,
+      changed,
+      session.initialized,
+      session.pendingDumpMode,
+    )
+  }
+
+  session.cwd = root
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != serveModeInitial || !changed {
+    t.Fatalf("repaired initial dump = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}
+
+// TestServeSessionRetriesAPendingDumpBeforeUnchanged pins the state boundary
+// introduced by dump-time path validation. A failed dump may occur after the
+// compiler generation and its hashes were captured; the next request must
+// retry that generation instead of confirming the older client graph as
+// unchanged.
+func TestServeSessionRetriesAPendingDumpBeforeUnchanged(t *testing.T) {
+  root := graphSessionFixture(t)
+  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)
+  }
+  session := &graphSession{
+    cwd:             root,
+    tsconfig:        "tsconfig.json",
+    compiler:        compiler,
+    initialized:     true,
+    pendingDumpMode: serveModeReload,
+  }
+  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 != serveModeReload || !changed {
+    t.Fatalf("pending dump retry = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+  if session.pendingDumpMode != "" {
+    t.Fatalf("successful retry left pending mode %q", session.pendingDumpMode)
+  }
+
+  dump, mode, changed, err = session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != serveModeUnchanged || changed {
+    t.Fatalf("retry did not converge: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}