ttsc 0.23.0 → 0.25.0

package/cmd/ttscgraph/serve_answers_a_project_that_implements_its_own_ambient_declaration_test.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestServeAnswersAProjectThatImplementsItsOwnAmbientDeclaration verifies shard
+// assembly succeeds for a project that declares an ambient global in its own
+// `.d.ts` and assigns the implementation elsewhere.
+//
+// Shard partition indexes edge sources by non-external node, and external nodes
+// live in a non-source shard that may own no edges. An edge leaving one is
+// therefore not a wrong fact but an unassemblable snapshot: the session refused
+// the whole transaction with "edge source node is absent from shard facts", so
+// every request failed before it ran while `dump`, which applies no such check,
+// still emitted the graph.
+//
+//  1. Serve a project whose `src/globals.d.ts` declares `var patched` and whose
+//     `src/index.ts` assigns an arrow function to it.
+//  2. Request one negotiated shard snapshot.
+//  3. Assert the response carries a complete transaction and no error.
+func TestServeAnswersAProjectThatImplementsItsOwnAmbientDeclaration(t *testing.T) {
+  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", "globals.d.ts"), `declare global {
+  var patched: (message: string) => void;
+}
+export {};
+`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), `export function helper(): void {}
+patched = (message: string): void => {
+  helper();
+};
+`)
+
+  input := strings.NewReader("{\"id\":1,\"graphSnapshotVersion\":1}\n")
+  var output bytes.Buffer
+  if code := serveSnapshots(input, &output, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("serveSnapshots exited %d: %s", code, output.String())
+  }
+
+  var initial serveResponse
+  if err := json.NewDecoder(&output).Decode(&initial); err != nil {
+    t.Fatal(err)
+  }
+  if initial.Error != "" {
+    t.Fatalf("shard assembly refused a project that implements its own ambient declaration: %s", initial.Error)
+  }
+  if initial.Mode != serveModeInitial || !initial.Changed || initial.Dump != nil || initial.Snapshot == nil {
+    t.Fatalf("negotiated initial response: %#v", initial)
+  }
+  if len(initial.Snapshot.Manifest) == 0 ||
+    len(initial.Snapshot.Upserts) != len(initial.Snapshot.Manifest) ||
+    len(initial.Snapshot.Deletes) != 0 {
+    t.Fatalf(
+      "initial transaction is not complete: manifest=%d upserts=%d deletes=%d",
+      len(initial.Snapshot.Manifest),
+      len(initial.Snapshot.Upserts),
+      len(initial.Snapshot.Deletes),
+    )
+  }
+}

package/cmd/ttscgraph/serve_early_error_encode_failure_is_observable_test.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+  "bytes"
+  "errors"
+  "strings"
+  "testing"
+)
+
+type rejectedServeWriter struct{}
+
+func (rejectedServeWriter) Write([]byte) (int, error) {
+  return 0, errors.New("synthetic response write failure")
+}
+
+// TestServeEarlyErrorEncodeFailureIsObservable proves a rejected early error
+// response fails the stream without claiming that an unencoded response ran.
+//
+//  1. Reject protocol negotiation before a graph session is constructed.
+//  2. Fail the response writer and require a nonzero server result.
+//  3. Require the stderr cause while forbidding successful phase rows.
+func TestServeEarlyErrorEncodeFailureIsObservable(t *testing.T) {
+  root := graphSessionFixture(t)
+  oldStderr := stderr
+  defer func() { stderr = oldStderr }()
+  t.Setenv(graphPhaseTraceEnvironment, "1")
+
+  var diagnostic bytes.Buffer
+  stderr = &diagnostic
+  request := "{\"id\":29,\"graphSnapshotVersion\":99}\n"
+  if code := serveSnapshots(strings.NewReader(request), rejectedServeWriter{}, root, "tsconfig.json"); code == 0 {
+    t.Fatal("failed early error encoding returned success")
+  }
+  if !strings.Contains(diagnostic.String(), "write serve response: synthetic response write failure") {
+    t.Fatalf("failed early error encoding hid its cause: %q", diagnostic.String())
+  }
+  if strings.Contains(diagnostic.String(), "ttscgraph-phase") {
+    t.Fatalf("failed early error encoding claimed successful phase rows: %q", diagnostic.String())
+  }
+}

package/cmd/ttscgraph/serve_graph_snapshot_version_matches_typescript_client_test.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "regexp"
+  "strconv"
+  "testing"
+)
+
+// TestServeGraphSnapshotVersionMatchesTypeScriptClient verifies the native
+// opt-in number and the resident client move together. The outer serve protocol
+// stays backward compatible, so only this explicit negotiation field can stop
+// an old full-dump client from misreading a shard response.
+func TestServeGraphSnapshotVersionMatchesTypeScriptClient(t *testing.T) {
+  source := filepath.Join("..", "..", "..", "graph", "src", "model", "TtscGraphSession.ts")
+  content, err := os.ReadFile(source)
+  if err != nil {
+    t.Fatal(err)
+  }
+  match := regexp.MustCompile(`const GRAPH_SNAPSHOT_PROTOCOL_VERSION = ([0-9]+);`).FindSubmatch(content)
+  if len(match) != 2 {
+    t.Fatalf("could not find GRAPH_SNAPSHOT_PROTOCOL_VERSION in %s", source)
+  }
+  version, err := strconv.Atoi(string(match[1]))
+  if err != nil {
+    t.Fatal(err)
+  }
+  if version != graphSnapshotProtocolVersion {
+    t.Fatalf("TypeScript client graph snapshot protocol v%d, native server v%d", version, graphSnapshotProtocolVersion)
+  }
+}

package/cmd/ttscgraph/serve_phase_trace_accounts_for_load_failure_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+  "bytes"
+  "strings"
+  "testing"
+)
+
+// TestServePhaseTraceAccountsForLoadFailure proves addressed requests retain a
+// complete timing record even when no resident compiler session can be built.
+//
+//  1. Request a missing tsconfig with phase tracing enabled.
+//  2. Require a normal addressed error response rather than process failure.
+//  3. Require all five payload-free phases under mode=error.
+func TestServePhaseTraceAccountsForLoadFailure(t *testing.T) {
+  root := graphSessionFixture(t)
+  request := "{\"id\":23,\"graphSnapshotVersion\":1}\n"
+  oldStderr := stderr
+  defer func() { stderr = oldStderr }()
+  t.Setenv(graphPhaseTraceEnvironment, "1")
+
+  var output bytes.Buffer
+  var trace bytes.Buffer
+  stderr = &trace
+  if code := serveSnapshots(strings.NewReader(request), &output, root, "missing-tsconfig.json"); code != 0 {
+    t.Fatalf("failed load exited %d", code)
+  }
+  if !strings.Contains(output.String(), `"id":23`) || !strings.Contains(output.String(), `"mode":"error"`) {
+    t.Fatalf("failed load omitted its addressed error response: %q", output.String())
+  }
+  for _, phase := range []string{
+    "native-load",
+    "semantic-refresh",
+    "shard-export",
+    "encode",
+    "producer-total",
+  } {
+    if !strings.Contains(trace.String(), "owner=producer request=23 mode=error phase="+phase+" durationMs=") {
+      t.Fatalf("failed-load trace omitted %s: %q", phase, trace.String())
+    }
+  }
+  if strings.Contains(trace.String(), root) || strings.Contains(trace.String(), "missing-tsconfig") || strings.Contains(trace.String(), "{\"") {
+    t.Fatalf("failed-load trace exposed request or project content: %q", trace.String())
+  }
+}

package/cmd/ttscgraph/serve_phase_trace_is_opt_in_and_payload_free_test.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+  "bytes"
+  "strings"
+  "testing"
+)
+
+// TestServePhaseTraceIsOptInAndPayloadFree proves the benchmark diagnostic is
+// disabled by default and exposes timings without project or request content.
+//
+//  1. Run the same native shard request with tracing disabled and enabled.
+//  2. Capture only the server diagnostic stream, not the response payload.
+//  3. Require the five named phases and reject fixture paths and JSON bodies.
+func TestServePhaseTraceIsOptInAndPayloadFree(t *testing.T) {
+  root := graphSessionFixture(t)
+  request := "{\"id\":17,\"graphSnapshotVersion\":1}\n"
+  oldStderr := stderr
+  defer func() { stderr = oldStderr }()
+
+  t.Setenv(graphPhaseTraceEnvironment, "")
+  var disabled bytes.Buffer
+  stderr = &disabled
+  if code := serveSnapshots(strings.NewReader(request), &bytes.Buffer{}, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("disabled trace exited %d", code)
+  }
+  if disabled.Len() != 0 {
+    t.Fatalf("disabled trace wrote %q", disabled.String())
+  }
+
+  t.Setenv(graphPhaseTraceEnvironment, "1")
+  var enabled bytes.Buffer
+  stderr = &enabled
+  if code := serveSnapshots(strings.NewReader(request), &bytes.Buffer{}, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("enabled trace exited %d", code)
+  }
+  trace := enabled.String()
+  for _, phase := range []string{
+    "native-load",
+    "semantic-refresh",
+    "shard-export",
+    "encode",
+    "producer-total",
+  } {
+    if !strings.Contains(trace, "owner=producer request=17 mode=initial phase="+phase+" durationMs=") {
+      t.Fatalf("trace omitted %s: %q", phase, trace)
+    }
+  }
+  if strings.Contains(trace, root) || strings.Contains(trace, "graphSnapshotVersion") || strings.Contains(trace, "{\"") {
+    t.Fatalf("trace exposed request or project content: %q", trace)
+  }
+}

package/cmd/ttscgraph/serve_protocol_negotiates_incremental_shards_test.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+// TestServeProtocolNegotiatesIncrementalShards pins the opt-in boundary between
+// existing full-dump clients and the native shard protocol. A negotiated first
+// response carries one complete manifest and transaction, while the following
+// no-op carries neither a dump nor a shard payload.
+func TestServeProtocolNegotiatesIncrementalShards(t *testing.T) {
+  root := graphSessionFixture(t)
+  input := strings.NewReader("{\"id\":1,\"graphSnapshotVersion\":1}\n{\"id\":2,\"graphSnapshotVersion\":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 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.Error != "" || initial.Mode != serveModeInitial || !initial.Changed || initial.Dump != nil || initial.Snapshot == nil {
+    t.Fatalf("negotiated initial response: %#v", initial)
+  }
+  snapshot := initial.Snapshot
+  if snapshot.ProtocolVersion != graphSnapshotProtocolVersion || snapshot.Sequence != 1 || snapshot.BaseSequence != 0 || snapshot.BaseGeneration != "" {
+    t.Fatalf("initial transaction coordinates: %#v", snapshot)
+  }
+  if len(snapshot.Manifest) == 0 || len(snapshot.Upserts) != len(snapshot.Manifest) || len(snapshot.Deletes) != 0 {
+    t.Fatalf("initial transaction is not complete: manifest=%d upserts=%d deletes=%d", len(snapshot.Manifest), len(snapshot.Upserts), len(snapshot.Deletes))
+  }
+  if unchanged.Error != "" || unchanged.Mode != serveModeUnchanged || unchanged.Changed || unchanged.Dump != nil || unchanged.Snapshot != nil {
+    t.Fatalf("negotiated unchanged response: %#v", unchanged)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_commonjs_package_entry_for_esm_test.go

@@ -39,12 +39,12 @@ func TestServeSessionReloadsCommonJSPackageEntryForESM(t *testing.T) {
     t.Fatal(err)
   }
 
-  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "main.ts"), "export function winner(): void {}\nexport function packageEntryWinner(): void {}\n")
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "main.ts"), "export function winner(): void {}\n")
   dump, mode, changed, err := session.Snapshot()
   if err != nil {
     t.Fatal(err)
   }
-  if dump == nil || mode != serveModeReload || !changed || !hasDumpNode(*dump, "packageEntryWinner") {
+  if dump == nil || mode != serveModeReload || !changed || !hasDumpNodeAt(*dump, "winner", "node_modules/fixture-package/dist/main.ts") {
     t.Fatalf("CommonJS package main.ts = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
   }
 }

package/cmd/ttscgraph/serve_session_reloads_superseding_module_candidates_test.go

@@ -2,7 +2,10 @@ package main
 
 import (
   "path/filepath"
+  "strings"
   "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
 )
 
 // TestServeSessionReloadsSupersedingModuleCandidates verifies a resident
@@ -15,13 +18,14 @@ import (
 //
 //  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.
+//  3. Assert the resident snapshot reloads and the imported symbol resolves to
+//     the newly preferred file. Package internals remain external boundaries.
 func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
   cases := []struct {
-    name  string
-    setup func(*testing.T, string) string
-    add   func(*testing.T, string)
+    name           string
+    setup          func(*testing.T, string) string
+    add            func(*testing.T, string)
+    wantDiagnostic string
   }{
     {
       name: "relative_extension",
@@ -32,10 +36,10 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
 }`)
         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"
+        return "src/value.ts"
       },
       add: func(t *testing.T, root string) {
-        writeGraphFile(t, filepath.Join(root, "src", "value.ts"), "export function winner(): void {}\nexport function typescriptWinner(): void {}\n")
+        writeGraphFile(t, filepath.Join(root, "src", "value.ts"), "export function winner(): void {}\n")
       },
     },
     {
@@ -52,10 +56,10 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
 }`)
         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"
+        return "first/value.ts"
       },
       add: func(t *testing.T, root string) {
-        writeGraphFile(t, filepath.Join(root, "first", "value.ts"), "export function winner(): void {}\nexport function firstPathsWinner(): void {}\n")
+        writeGraphFile(t, filepath.Join(root, "first", "value.ts"), "export function winner(): void {}\n")
       },
     },
     {
@@ -71,10 +75,10 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
 }`)
         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"
+        return "src/views/template.ts"
       },
       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")
+        writeGraphFile(t, filepath.Join(root, "src", "views", "template.ts"), "export function winner(): void {}\n")
       },
     },
     {
@@ -86,10 +90,10 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
 }`)
         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"
+        return "src/node_modules/fixture-package/index.ts"
       },
       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")
+        writeGraphFile(t, filepath.Join(root, "src", "node_modules", "fixture-package", "index.ts"), "export function winner(): void {}\n")
       },
     },
     {
@@ -113,8 +117,9 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
         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")
+        writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "first.js"), "export function winner() {}\n")
       },
+      wantDiagnostic: "node_modules/fixture-package/dist/first.js",
     },
     {
       name: "conditional_package_exports",
@@ -139,7 +144,7 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
   }
 }`)
         writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "fallback.js"), "export function winner() {}\n")
-        return ""
+        return "node_modules/fixture-package/dist/types.d.ts"
       },
       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")
@@ -168,7 +173,7 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
 }`)
         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 ""
+        return "generated/types.d.ts"
       },
       add: func(t *testing.T, root string) {
         writeGraphFile(t, filepath.Join(root, "generated", "types.d.ts"), "export declare function winner(): void;\n")
@@ -183,10 +188,10 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
 }`)
         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"
+        return "src/feature.js"
       },
       add: func(t *testing.T, root string) {
-        writeGraphFile(t, filepath.Join(root, "src", "feature.js"), "export function winner() {}\nexport function fileWinner() {}\n")
+        writeGraphFile(t, filepath.Join(root, "src", "feature.js"), "export function winner() {}\n")
       },
     },
   }
@@ -208,9 +213,30 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
       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)
+      if dump == nil || mode != serveModeReload || !changed ||
+        (want != "" && !hasDumpNodeAt(*dump, "winner", want)) ||
+        (test.wantDiagnostic != "" && !hasDumpDiagnosticContaining(*dump, test.wantDiagnostic)) {
+        t.Fatalf("superseding candidate = dump:%v mode:%q changed:%v want-file:%q want-diagnostic:%q", dump != nil, mode, changed, want, test.wantDiagnostic)
       }
     })
   }
 }
+
+func hasDumpNodeAt(dump graph.Dump, name, fileSuffix string) bool {
+  suffix := filepath.ToSlash(fileSuffix)
+  for _, node := range dump.Nodes {
+    if node.Name == name && strings.HasSuffix(filepath.ToSlash(node.File), suffix) {
+      return true
+    }
+  }
+  return false
+}
+
+func hasDumpDiagnosticContaining(dump graph.Dump, fragment string) bool {
+  for _, diagnostic := range dump.Diagnostics {
+    if strings.Contains(filepath.ToSlash(diagnostic.Message), filepath.ToSlash(fragment)) {
+      return true
+    }
+  }
+  return false
+}

package/cmd/ttscgraph/serve_session_retries_failed_dump_test.go

@@ -36,13 +36,13 @@ func TestServeSessionKeepsChangeDetectionLiveAfterInitialDumpError(t *testing.T)
   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 {
+  if dump != nil || changed || !session.initialized || session.pending == nil || session.pending.mode != serveModeInitial {
     t.Fatalf(
       "failed initial state = dump:%v changed:%v initialized:%v pending:%q",
       dump != nil,
       changed,
       session.initialized,
-      session.pendingDumpMode,
+      session.pending.mode,
     )
   }
 
@@ -71,11 +71,11 @@ func TestServeSessionRetriesAPendingDumpBeforeUnchanged(t *testing.T) {
     t.Fatalf("NewSession returned nil session (diagnostics: %v)", diags)
   }
   session := &graphSession{
-    cwd:             root,
-    tsconfig:        "tsconfig.json",
-    compiler:        compiler,
-    initialized:     true,
-    pendingDumpMode: serveModeReload,
+    cwd:         root,
+    tsconfig:    "tsconfig.json",
+    compiler:    compiler,
+    initialized: true,
+    pending:     &graphChange{mode: serveModeReload, full: true},
   }
   defer session.Close()
   if err := session.captureState(); err != nil {
@@ -89,8 +89,8 @@ func TestServeSessionRetriesAPendingDumpBeforeUnchanged(t *testing.T) {
   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)
+  if session.pending != nil {
+    t.Fatalf("successful retry left pending change %#v", session.pending)
   }
 
   dump, mode, changed, err = session.Snapshot()