ttsc 0.21.0 → 0.23.0

package/internal/lspserver/lsp_reload_directories_compare_immediate_topology_test.go

@@ -0,0 +1,188 @@
+package lspserver
+
+import (
+  "net/url"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestLSPReloadDirectoriesCompareImmediateTopology verifies reload-directory
+// notifications restart only when the declared non-recursive topology changes.
+//
+// A directory fingerprint represents resolution identity, not the contents of
+// every child. Treating every descendant event as a restart turns ordinary
+// edits into crashes, while ignoring directory identity or symlink targets
+// leaves contributor selection stale.
+//
+//  1. Record a directory with one file and one nested directory.
+//  2. Prove child-content and nested-descendant edits leave its digest stable.
+//  3. Prove immediate creation and deletion change the digest.
+//  4. Prove deleting the watched directory itself changes the digest.
+//  5. Where supported, retarget a symlink without renaming it and prove the raw
+//     link target participates in the digest.
+//  6. Replace an empty directory with the same topology and prove its identity
+//     event still restarts selection.
+//  7. Nest one reload directory in another and prove the unchanged parent
+//     cannot hide an immediate topology change in the child.
+//  8. Rediscover project inputs after topology drift and prove refresh retains
+//     the selection-time baseline until the server restarts.
+func TestLSPReloadDirectoriesCompareImmediateTopology(t *testing.T) {
+  root := t.TempDir()
+  reloadDirectory := filepath.Join(root, "config-deps")
+  nested := filepath.Join(reloadDirectory, "nested")
+  if err := os.MkdirAll(nested, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  selection := filepath.Join(reloadDirectory, "selection.cjs")
+  nestedSelection := filepath.Join(nested, "selection.cjs")
+  if err := os.WriteFile(selection, []byte("alpha"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(nestedSelection, []byte("alpha"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  changed := fileChangeTypeChanged
+  created := fileChangeTypeCreated
+  deleted := fileChangeTypeDeleted
+  uri := func(location string) string {
+    normalized := filepath.ToSlash(location)
+    if filepath.VolumeName(location) != "" {
+      normalized = "/" + normalized
+    }
+    return (&url.URL{Scheme: "file", Path: normalized}).String()
+  }
+  snapshot := func(directory string) LSPProjectInputSnapshot {
+    normalized, err := normalizeLSPProjectInputSnapshot(
+      LSPProjectInputSnapshot{
+        Root:              root,
+        ReloadDirectories: []string{directory},
+      },
+      root,
+    )
+    if err != nil {
+      t.Fatalf("normalize reload directory: %v", err)
+    }
+    return normalized
+  }
+  source := &NativePluginSource{projectInputs: snapshot(reloadDirectory)}
+
+  if err := os.WriteFile(selection, []byte("beta"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if source.ProjectInputReloadMatchesChange(uri(selection), &changed) {
+    t.Fatal("ordinary child-content edit changed directory topology")
+  }
+  if err := os.WriteFile(nestedSelection, []byte("beta"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if source.ProjectInputReloadMatchesChange(uri(nestedSelection), &changed) {
+    t.Fatal("nested descendant edit matched a non-recursive reload directory")
+  }
+
+  createdEntry := filepath.Join(reloadDirectory, "created.cjs")
+  if err := os.WriteFile(createdEntry, []byte("created"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if !source.ProjectInputReloadMatchesChange(uri(createdEntry), &created) {
+    t.Fatal("immediate entry creation did not change directory topology")
+  }
+  source.projectInputs = snapshot(reloadDirectory)
+  if err := os.Remove(createdEntry); err != nil {
+    t.Fatal(err)
+  }
+  if !source.ProjectInputReloadMatchesChange(uri(createdEntry), &deleted) {
+    t.Fatal("immediate entry deletion did not change directory topology")
+  }
+
+  deletionRoot := filepath.Join(root, "deleted-deps")
+  if err := os.Mkdir(deletionRoot, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  source.projectInputs = snapshot(deletionRoot)
+  if err := os.Remove(deletionRoot); err != nil {
+    t.Fatal(err)
+  }
+  if !source.ProjectInputReloadMatchesChange(uri(deletionRoot), &deleted) {
+    t.Fatal("reload-directory deletion did not change its topology state")
+  }
+
+  replacementRoot := filepath.Join(root, "replacement-deps")
+  if err := os.Mkdir(replacementRoot, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  source.projectInputs = snapshot(replacementRoot)
+  if err := os.Remove(replacementRoot); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.Mkdir(replacementRoot, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if !source.ProjectInputReloadMatchesChange(
+    uri(replacementRoot),
+    &created,
+  ) {
+    t.Fatal("same-topology directory replacement did not match its identity event")
+  }
+
+  nestedParent := filepath.Join(root, "nested-parent")
+  nestedChild := filepath.Join(nestedParent, "child")
+  if err := os.MkdirAll(nestedChild, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  nestedSnapshot, err := normalizeLSPProjectInputSnapshot(
+    LSPProjectInputSnapshot{
+      Root:              root,
+      ReloadDirectories: []string{nestedParent, nestedChild},
+    },
+    root,
+  )
+  if err != nil {
+    t.Fatalf("normalize nested reload directories: %v", err)
+  }
+  source.projectInputs = nestedSnapshot
+  nestedEntry := filepath.Join(nestedChild, "selection.cjs")
+  if err := os.WriteFile(nestedEntry, []byte("alpha"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if !source.ProjectInputReloadMatchesChange(uri(nestedEntry), &created) {
+    t.Fatal("unchanged parent reload directory hid nested topology change")
+  }
+
+  refreshRoot := filepath.Join(root, "refresh-deps")
+  if err := os.Mkdir(refreshRoot, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  baseline := snapshot(refreshRoot)
+  refreshEntry := filepath.Join(refreshRoot, "selection.cjs")
+  if err := os.WriteFile(refreshEntry, []byte("alpha"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  refreshed := snapshot(refreshRoot)
+  preserveProjectInputReloadFingerprints(baseline, &refreshed)
+  source.projectInputs = refreshed
+  if !source.ProjectInputReloadMatchesChange(uri(refreshEntry), &created) {
+    t.Fatal("project-input refresh absorbed selection-time topology drift")
+  }
+
+  firstTarget := filepath.Join(root, "first-target")
+  secondTarget := filepath.Join(root, "second-target")
+  for _, target := range []string{firstTarget, secondTarget} {
+    if err := os.Mkdir(target, 0o755); err != nil {
+      t.Fatal(err)
+    }
+  }
+  link := filepath.Join(reloadDirectory, "selection-link")
+  if err := os.Symlink(firstTarget, link); err == nil {
+    source.projectInputs = snapshot(reloadDirectory)
+    if err := os.Remove(link); err != nil {
+      t.Fatal(err)
+    }
+    if err := os.Symlink(secondTarget, link); err != nil {
+      t.Fatalf("retarget symlink: %v", err)
+    }
+    if !source.ProjectInputReloadMatchesChange(uri(link), &changed) {
+      t.Fatal("symlink retarget did not change directory topology")
+    }
+  }
+}

package/internal/lspserver/lsp_reload_directories_separate_glob_territory_test.go

@@ -0,0 +1,181 @@
+package lspserver
+
+import (
+  "net/url"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestLSPReloadDirectoriesSeparateGlobTerritory verifies the native LSP host
+// applies the same data-versus-selection boundary as the CLI watcher.
+//
+// A reload directory records resolution topology, but a declared glob's
+// literal root appearing strictly below it is an ordinary data-population
+// transition. Restarting the JavaScript launcher for that event loses the
+// resident process that should instead reload its Program.
+//
+//  1. Create a missing glob root directly inside a reload directory and prove
+//     it remains on the warm data lane.
+//  2. Prove unrelated immediate entries and the directory itself remain cold.
+//  3. Prove exact reload files are never exempt inside glob territory.
+//  4. Prove a glob rooted on or above the reload directory exempts nothing.
+func TestLSPReloadDirectoriesSeparateGlobTerritory(t *testing.T) {
+  uri := func(location string) string {
+    normalized := filepath.ToSlash(location)
+    if filepath.VolumeName(location) != "" {
+      normalized = "/" + normalized
+    }
+    return (&url.URL{Scheme: "file", Path: normalized}).String()
+  }
+  snapshot := func(
+    root string,
+    globs []string,
+    reloadFiles []string,
+  ) LSPProjectInputSnapshot {
+    normalized, err := normalizeLSPProjectInputSnapshot(
+      LSPProjectInputSnapshot{
+        Root:              root,
+        Globs:             globs,
+        ReloadFiles:       reloadFiles,
+        ReloadDirectories: []string{root},
+      },
+      root,
+    )
+    if err != nil {
+      t.Fatalf("normalize project inputs: %v", err)
+    }
+    return normalized
+  }
+  created := fileChangeTypeCreated
+  changed := fileChangeTypeChanged
+
+  t.Run("literal root is data", func(t *testing.T) {
+    root := t.TempDir()
+    globRoot := filepath.Join(root, "api")
+    source := &NativePluginSource{
+      projectInputs: snapshot(
+        root,
+        []string{filepath.Join(globRoot, "**", "*.json")},
+        nil,
+      ),
+    }
+    if err := os.Mkdir(globRoot, 0o755); err != nil {
+      t.Fatal(err)
+    }
+    if source.ProjectInputReloadMatchesChange(uri(globRoot), &created) {
+      t.Fatal("declared glob root selected a cold launcher restart")
+    }
+
+    source.projectInputs = snapshot(
+      root,
+      []string{filepath.Join(globRoot, "**", "*.json")},
+      nil,
+    )
+    selectionEntry := filepath.Join(root, "new-package")
+    if err := os.Mkdir(selectionEntry, 0o755); err != nil {
+      t.Fatal(err)
+    }
+    if !source.ProjectInputReloadMatchesChange(uri(selectionEntry), &created) {
+      t.Fatal("unrelated immediate entry did not select a cold restart")
+    }
+    if !source.ProjectInputReloadMatchesChange(uri(root), &changed) {
+      t.Fatal("reload-directory identity event depended on its change type")
+    }
+  })
+
+  t.Run("exact file is never data", func(t *testing.T) {
+    root := t.TempDir()
+    globRoot := filepath.Join(root, "api")
+    reloadFile := filepath.Join(globRoot, "selection.json")
+    source := &NativePluginSource{
+      projectInputs: snapshot(
+        root,
+        []string{filepath.Join(globRoot, "**", "*.json")},
+        []string{reloadFile},
+      ),
+    }
+    if err := os.Mkdir(globRoot, 0o755); err != nil {
+      t.Fatal(err)
+    }
+    if err := os.WriteFile(reloadFile, []byte("{}"), 0o644); err != nil {
+      t.Fatal(err)
+    }
+    if !source.ProjectInputReloadMatchesChange(uri(reloadFile), &created) {
+      t.Fatal("exact reload file was exempted by surrounding glob territory")
+    }
+  })
+
+  t.Run("symlinked literal root is data", func(t *testing.T) {
+    root := t.TempDir()
+    globRoot := filepath.Join(root, "api")
+    physicalData := filepath.Join(root, "data")
+    if err := os.Mkdir(physicalData, 0o755); err != nil {
+      t.Fatal(err)
+    }
+    source := &NativePluginSource{
+      projectInputs: snapshot(
+        root,
+        []string{filepath.Join(globRoot, "**", "*.json")},
+        nil,
+      ),
+    }
+    if err := os.Symlink(physicalData, globRoot); err != nil {
+      t.Skipf("directory symlinks unavailable: %v", err)
+    }
+    if source.ProjectInputReloadMatchesChange(uri(globRoot), &created) {
+      t.Fatal("symlinked glob root lost its physical data identity")
+    }
+  })
+
+  t.Run("symlinked literal root outside reload directory is selection", func(t *testing.T) {
+    root := t.TempDir()
+    globRoot := filepath.Join(root, "api")
+    physicalData := t.TempDir()
+    source := &NativePluginSource{
+      projectInputs: snapshot(
+        root,
+        []string{filepath.Join(globRoot, "**", "*.json")},
+        nil,
+      ),
+    }
+    if err := os.Symlink(physicalData, globRoot); err != nil {
+      t.Skipf("directory symlinks unavailable: %v", err)
+    }
+    if !source.ProjectInputReloadMatchesChange(uri(globRoot), &created) {
+      t.Fatal("glob root outside reload directory exempted selection")
+    }
+  })
+
+  for _, test := range []struct {
+    name string
+    glob func(string) string
+  }{
+    {
+      name: "rooted on reload directory",
+      glob: func(root string) string {
+        return filepath.Join(root, "**", "*.json")
+      },
+    },
+    {
+      name: "rooted above reload directory",
+      glob: func(root string) string {
+        return filepath.Join(filepath.Dir(root), "**", "*.json")
+      },
+    },
+  } {
+    t.Run(test.name, func(t *testing.T) {
+      root := t.TempDir()
+      source := &NativePluginSource{
+        projectInputs: snapshot(root, []string{test.glob(root)}, nil),
+      }
+      entry := filepath.Join(root, "new-package")
+      if err := os.Mkdir(entry, 0o755); err != nil {
+        t.Fatal(err)
+      }
+      if !source.ProjectInputReloadMatchesChange(uri(entry), &created) {
+        t.Fatal("glob at or above reload directory exempted selection entry")
+      }
+    })
+  }
+}

package/internal/lspserver/lsp_reload_file_fingerprint_preserves_raw_symlink_target_test.go

@@ -0,0 +1,47 @@
+package lspserver
+
+import (
+  "bytes"
+  "crypto/sha256"
+  "fmt"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestReloadFileFingerprintPreservesRawSymlinkTarget verifies the Go startup
+// validator hashes exact-file symlinks with the launcher's byte protocol.
+//
+// Decoding a POSIX link target as UTF-8 replaces invalid bytes, making an
+// unchanged launcher snapshot disagree with the native validator forever. The
+// capability check keeps the vector portable to filesystems that cannot retain
+// the raw name while requiring byte fidelity wherever they can.
+//
+//  1. Create a dangling symlink with a non-UTF-8 raw target where supported.
+//  2. Read it back and continue only when the filesystem preserved the bytes.
+//  3. Hash the protocol's symlink, raw target, and missing-content records.
+//  4. Assert the production fingerprint is exactly that digest.
+func TestReloadFileFingerprintPreservesRawSymlinkTarget(t *testing.T) {
+  target := string([]byte{0xff, 'x'})
+  link := filepath.Join(t.TempDir(), "reload-link")
+  if err := os.Symlink(target, link); err != nil {
+    return
+  }
+  retained, err := os.Readlink(link)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !bytes.Equal([]byte(retained), []byte(target)) {
+    return
+  }
+
+  digest := sha256.New()
+  digest.Write([]byte("symlink\x00"))
+  digest.Write([]byte(target))
+  digest.Write([]byte{0})
+  digest.Write([]byte("missing\x00"))
+  expected := fmt.Sprintf("%x", digest.Sum(nil))
+  if got := projectInputReloadFileDigest(link); got != expected {
+    t.Fatalf("reload symlink digest = %s, want raw-byte protocol %s", got, expected)
+  }
+}

package/internal/lspserver/lsp_resident_falls_back_when_serve_unsupported_test.go

@@ -31,7 +31,7 @@ func TestResidentFallsBackWhenServeUnsupported(t *testing.T) {
   }
 
   source.residentMu.Lock()
-  unsupported := source.serveUnsupported[plugin.Binary]
+  unsupported := source.serveUnsupported[pluginKey(plugin)]
   source.residentMu.Unlock()
   if !unsupported {
     t.Fatal("a first-spawn failure must mark lsp-serve unsupported so the source stops retrying")

package/internal/lspserver/lsp_resident_invalidation_broadcasts_program_input_overlap_test.go

@@ -0,0 +1,60 @@
+package lspserver
+
+import "testing"
+
+// TestLSPResidentInvalidationBroadcastsProgramInputOverlap verifies an input's
+// contributor ownership never hides its second role as a shared Program input.
+//
+// A TypeScript source or resolveJsonModule JSON file can be declared by one
+// producer while belonging to every resident Program. All residents must see
+// the content delta; the daemon itself skips an external path when its Program
+// does not contain it.
+//
+//  1. Install two resident entries with distinct producer keys.
+//  2. Attribute one shared-Program URI to the first producer only.
+//  3. Assert both residents receive the changed and external deltas.
+func TestLSPResidentInvalidationBroadcastsProgramInputOverlap(t *testing.T) {
+  for _, externalURI := range []string{
+    "file:///project/src/shared.ts",
+    "file:///project/src/shared.json",
+  } {
+    t.Run(externalURI, func(t *testing.T) {
+      first := NativeLSPPluginEntry{Binary: "first", Name: "@ttsc/first"}
+      second := NativeLSPPluginEntry{Binary: "second", Name: "@ttsc/second"}
+      firstResident := &residentSidecar{}
+      secondResident := &residentSidecar{}
+      source := &NativePluginSource{
+        plugins: []NativeLSPPluginEntry{first, second},
+        residents: map[string]*residentSidecar{
+          pluginKey(first):  firstResident,
+          pluginKey(second): secondResident,
+        },
+      }
+
+      source.InvalidateResidentProgramsForOwnedWatchedChanges(
+        []string{externalURI},
+        []string{externalURI},
+        map[string][]string{
+          externalURI: {pluginKey(first)},
+        },
+      )
+
+      for label, resident := range map[string]*residentSidecar{
+        "owner":     firstResident,
+        "non-owner": secondResident,
+      } {
+        if len(resident.changed) != 1 ||
+          resident.changed[0] != externalURI ||
+          len(resident.external) != 1 ||
+          resident.external[0] != externalURI {
+          t.Fatalf(
+            "%s resident deltas = changed %#v, external %#v",
+            label,
+            resident.changed,
+            resident.external,
+          )
+        }
+      }
+    })
+  }
+}

package/internal/lspserver/lsp_resident_invalidation_targets_project_input_owners_test.go

@@ -0,0 +1,51 @@
+package lspserver
+
+import "testing"
+
+// TestLSPResidentInvalidationTargetsProjectInputOwners verifies external data
+// changes reach only resident binaries whose producer declared the input.
+//
+//  1. Install two resident entries with distinct producer keys.
+//  2. Attribute one external URI to the first producer.
+//  3. Assert only the first resident receives changed/external deltas.
+func TestLSPResidentInvalidationTargetsProjectInputOwners(t *testing.T) {
+  first := NativeLSPPluginEntry{Binary: "first", Name: "@ttsc/first"}
+  second := NativeLSPPluginEntry{Binary: "second", Name: "@ttsc/second"}
+  firstResident := &residentSidecar{}
+  secondResident := &residentSidecar{}
+  source := &NativePluginSource{
+    plugins: []NativeLSPPluginEntry{first, second},
+    residents: map[string]*residentSidecar{
+      pluginKey(first):  firstResident,
+      pluginKey(second): secondResident,
+    },
+  }
+  const externalURI = "file:///project/docs/spec.md"
+
+  source.InvalidateResidentProgramsForOwnedWatchedChanges(
+    []string{externalURI},
+    []string{externalURI},
+    map[string][]string{
+      externalURI: {pluginKey(first)},
+    },
+  )
+
+  if len(firstResident.changed) != 1 ||
+    firstResident.changed[0] != externalURI ||
+    len(firstResident.external) != 1 ||
+    firstResident.external[0] != externalURI {
+    t.Fatalf(
+      "owned resident deltas = changed %#v, external %#v",
+      firstResident.changed,
+      firstResident.external,
+    )
+  }
+  if len(secondResident.changed) != 0 ||
+    len(secondResident.external) != 0 {
+    t.Fatalf(
+      "unrelated resident received deltas = changed %#v, external %#v",
+      secondResident.changed,
+      secondResident.external,
+    )
+  }
+}

package/internal/lspserver/lsp_same_transport_entries_are_deduplicated_test.go

@@ -0,0 +1,66 @@
+package lspserver
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestLSPSameTransportEntriesAreDeduplicated verifies logical manifest entries
+// sharing one effective native launch identity produce one aggregate result.
+//
+// Native verbs receive the full plugin manifest and no selected-entry key. A
+// composed aggregate and leaf can therefore have distinct names while invoking
+// the same binary with the same argv; treating them as separate producers would
+// duplicate diagnostics, inputs, completion hints, and command discovery.
+func TestLSPSameTransportEntriesAreDeduplicated(t *testing.T) {
+  aggregate := NativeLSPPluginEntry{
+    Binary:             "shared-sidecar",
+    Name:               "@ttsc/aggregate",
+    ProjectDiagnostics: true,
+    ProjectInputs:      true,
+    Stage:              "check",
+  }
+  leaf := aggregate
+  leaf.Name = "@ttsc/leaf"
+
+  selected := selectPluginTransports(
+    []NativeLSPPluginEntry{aggregate, leaf},
+    nil,
+  )
+  if len(selected) != 1 || selected[0].Name != aggregate.Name {
+    t.Fatalf("same launch transport selection = %#v", selected)
+  }
+
+  root := t.TempDir()
+  snapshot := LSPProjectInputSnapshot{
+    Root:  root,
+    Files: []string{filepath.Join(root, "spec.md")},
+  }
+  source := &NativePluginSource{
+    plugins: []NativeLSPPluginEntry{aggregate, leaf},
+  }
+  source.storeProjectInputs(aggregate, 1, snapshot)
+  source.storeProjectInputs(leaf, 1, snapshot)
+  owners := source.ProjectInputOwnersForURI(testFileURI(snapshot.Files[0]))
+  if len(owners) != 1 || owners[0] != pluginKey(aggregate) {
+    t.Fatalf("same transport input owners = %#v", owners)
+  }
+
+  publication := &LSPProjectDiagnostics{
+    URI: "file:///tsconfig.json",
+    Diagnostics: []LSPDiagnostic{
+      {Message: "one aggregate finding"},
+    },
+  }
+  source.storeProjectDiagnostics(aggregate, 1, publication)
+  source.storeProjectDiagnostics(leaf, 1, publication)
+  merged := source.projectDiagnosticsSnapshot()
+  if merged == nil || len(merged.Diagnostics) != 1 {
+    t.Fatalf("same transport project publication = %#v", merged)
+  }
+
+  result := source.ProjectDiagnosticsForOwners(nil)
+  if result.selected != 1 {
+    t.Fatalf("same transport selected %d project producers", result.selected)
+  }
+}

package/lib/compiler/internal/project/readProjectConfig.d.ts

@@ -5,8 +5,10 @@ import type { ITtscProjectLocatorOptions } from "../../../structures/internal/IT
  *
  * Follows `extends` chains (including arrays) and merges compiler options with
  * later configs taking precedence. Path-typed options (`baseUrl`,
- * `declarationDir`, `rootDir`) are resolved relative to the config that
- * declares them. The `outDir` is resolved to an absolute path. Plugins are
- * inherited from the nearest ancestor that declares them.
+ * `declarationDir`, `outFile`, `rootDir`, `tsBuildInfoFile`) are resolved
+ * relative to the config that declares them. `${configDir}` paths are resolved
+ * against the final consuming config after the extends chain is merged. The
+ * `outDir` is resolved to an absolute path. Plugins are inherited from the
+ * nearest ancestor that declares them.
  */
 export declare function readProjectConfig(opts?: ITtscProjectLocatorOptions): ITtscParsedProjectConfig;