@ttsc/evidence 0.29.0 → 0.30.1

package/native/loader.go

@@ -22,12 +22,17 @@ import (
 // that symbol is precisely the one an obligation needs to name — an evidence
 // graph exists to report the operation the frontend never called.
 type typeScriptLoader struct {
-  root     string
-  program  map[string]*artifactInventory
-  parsed   map[string]*artifactInventory
-  resolved map[string]string
-  failures map[string]string
-  installs map[string]installedPackageLocation
+  boundary      *populationBase
+  root          string
+  identityRoot  string
+  program       map[string]*artifactInventory
+  programIDs    map[string]*artifactInventory
+  parsed        map[string]*artifactInventory
+  resolved      map[string]string
+  failures      map[string]string
+  parseFailures map[string]string
+  identities    map[string]typeScriptModuleIdentity
+  installs      map[string]installedPackageLocation
 }
 
 func newTypeScriptLoader(
@@ -35,23 +40,40 @@ func newTypeScriptLoader(
   program map[string]*artifactInventory,
 ) *typeScriptLoader {
   loader := &typeScriptLoader{
-    root:     strings.ReplaceAll(root, "\\", "/"),
-    program:  map[string]*artifactInventory{},
-    parsed:   map[string]*artifactInventory{},
-    resolved: map[string]string{},
-    failures: map[string]string{},
-    installs: map[string]installedPackageLocation{},
-  }
-  for _, inventory := range program {
+    root:          strings.ReplaceAll(root, "\\", "/"),
+    program:       map[string]*artifactInventory{},
+    programIDs:    map[string]*artifactInventory{},
+    parsed:        map[string]*artifactInventory{},
+    resolved:      map[string]string{},
+    failures:      map[string]string{},
+    parseFailures: map[string]string{},
+    identities:    map[string]typeScriptModuleIdentity{},
+    installs:      map[string]installedPackageLocation{},
+  }
+  loader.identityRoot, _ = physicalTypeScriptPath(filepath.FromSlash(loader.root))
+  keys := make([]string, 0, len(program))
+  for key := range program {
+    keys = append(keys, key)
+  }
+  sort.Strings(keys)
+  for _, key := range keys {
+    inventory := program[key]
     if inventory == nil || inventory.Path == "" {
       continue
     }
     location := loader.projectPath(inventory.Path)
+    identity, _ := loader.moduleIdentity(location)
+    if inventory.Address != identity && inventory.Source != nil {
+      inventory = typeScriptInventories.scan(typeScriptModuleAddress(location, identity), inventory.Source)
+    }
     current := loader.program[location]
     if current == nil ||
       current.Address != current.Path && inventory.Address == inventory.Path {
       loader.program[location] = inventory
     }
+    if loader.programIDs[identity] == nil || location == identity {
+      loader.programIDs[identity] = inventory
+    }
   }
   return loader
 }
@@ -60,24 +82,41 @@ func newTypeScriptLoader(
 //
 // The Program's copy wins when it exists so that a file under edit is read as
 // the editor has it, not as the disk last saw it.
-func (loader *typeScriptLoader) inventory(relative string) *artifactInventory {
+func (loader *typeScriptLoader) inventory(relative string) (result *artifactInventory) {
   if relative == "" {
     return nil
   }
   relative = loader.projectPath(relative)
-  if inventory := loader.program[relative]; inventory != nil {
+  if !loader.withinBoundary(relative) {
+    loader.failures[relative] = "the re-export leaves the explicitly configured root"
+    return nil
+  }
+  defer func() {
+    if loader.boundary != nil && result != nil && result.Source != nil && len(result.Source.Diagnostics()) != 0 {
+      diagnostic := result.Source.Diagnostics()[0]
+      loader.failures[relative] = "TypeScript syntax error TS" + decimal(int(diagnostic.Code())) + " at line " + decimal(lineAt(result.Source.Text(), diagnostic.Pos()))
+      result = nil
+    }
+  }()
+  if inventory := loader.programInventory(relative); inventory != nil {
     return inventory
   }
   if inventory, cached := loader.parsed[relative]; cached {
+    if inventory == nil && loader.parseFailures[relative] != "" {
+      loader.failures[relative] = loader.parseFailures[relative]
+    }
     return inventory
   }
   loader.parsed[relative] = loader.parse(relative)
+  if loader.parsed[relative] == nil {
+    loader.parseFailures[relative] = loader.failures[relative]
+  }
   return loader.parsed[relative]
 }
 
 func (loader *typeScriptLoader) parse(relative string) *artifactInventory {
   relative = loader.projectPath(relative)
-  content, err := os.ReadFile(path.Join(loader.root, relative))
+  content, err := os.ReadFile(resolveProjectPath(loader.root, relative))
   if err != nil {
     loader.failures[relative] = err.Error()
     return nil
@@ -88,7 +127,7 @@ func (loader *typeScriptLoader) parse(relative string) *artifactInventory {
   }
   file := shimparser.ParseSourceFile(
     shimast.SourceFileParseOptions{
-      FileName: path.Join(loader.root, relative),
+      FileName: filepath.ToSlash(resolveProjectPath(loader.root, relative)),
     },
     string(content),
     kind,
@@ -97,7 +136,8 @@ func (loader *typeScriptLoader) parse(relative string) *artifactInventory {
     loader.failures[relative] = "the TypeScript parser returned no source file"
     return nil
   }
-  return scanTypeScriptInventory(relative, file)
+  identity, _ := loader.moduleIdentity(relative)
+  return scanTypeScriptInventoryAt(typeScriptModuleAddress(relative, identity), file)
 }
 
 func (loader *typeScriptLoader) failure(relative string) string {
@@ -111,19 +151,34 @@ func (loader *typeScriptLoader) failure(relative string) string {
 // without paying to scan it.
 func (loader *typeScriptLoader) exists(relative string) bool {
   relative = loader.projectPath(relative)
-  if loader.program[relative] != nil {
+  if loader.programInventory(relative) != nil {
     return true
   }
   return loader.existsOnDisk(relative)
 }
 
+// Authored module paths and physical identity keys are separate namespaces.
+// Mixing them can mistake a sibling of a linked root for a different sibling
+// of the physical project. Identity lookup still recovers its editor snapshot.
+func (loader *typeScriptLoader) programInventory(module string) *artifactInventory {
+  if inventory := loader.program[module]; inventory != nil {
+    return inventory
+  }
+  if len(loader.programIDs) != 0 {
+    if identity, ok := loader.moduleIdentity(module); ok {
+      return loader.programIDs[identity]
+    }
+  }
+  return nil
+}
+
 // existsOnDisk probes the filesystem for an already-normalized path.
 //
 // The probe is the expensive half of module resolution — one syscall per
 // candidate, and a watch cycle resolves every re-export in the population — so
 // callers that can answer from the Program should do that first.
 func (loader *typeScriptLoader) existsOnDisk(relative string) bool {
-  info, err := os.Stat(path.Join(loader.root, relative))
+  info, err := os.Stat(resolveProjectPath(loader.root, relative))
   return err == nil && !info.IsDir()
 }
 
@@ -135,6 +190,9 @@ func (loader *typeScriptLoader) resolve(from string, specifier string) string {
     return cached
   }
   loader.resolved[key] = loader.resolveUncached(from, specifier)
+  if loader.boundary != nil && loader.resolved[key] == "" && loader.failures[from+" -> "+specifier] == "" {
+    loader.failures[from+" -> "+specifier] = "the exported module cannot be resolved"
+  }
   return loader.resolved[key]
 }
 
@@ -142,12 +200,19 @@ func (loader *typeScriptLoader) resolveUncached(
   from string,
   specifier string,
 ) string {
+  failure := from + " -> " + specifier
   if strings.HasPrefix(specifier, "./") || strings.HasPrefix(specifier, "../") {
+    if loader.boundary != nil {
+      if canonical, ok := loader.moduleIdentity(from); ok {
+        from = filepath.ToSlash(resolveProjectPath(loader.identityRoot, canonical))
+      }
+    }
     base := path.Clean(path.Join(path.Dir(from), specifier))
     candidates := moduleCandidates(base)
     normalized := make([]string, 0, len(candidates))
     for _, candidate := range candidates {
-      normalized = append(normalized, loader.projectPath(candidate))
+      module := loader.projectPath(candidate)
+      normalized = append(normalized, module)
     }
     // The Program answers first, and not only because it answers without a
     // syscall. A project that emits beside its sources has both `x.js` and
@@ -155,12 +220,20 @@ func (loader *typeScriptLoader) resolveUncached(
     // resolving an import to emitted JavaScript would read a module whose
     // declarations the graph cannot address.
     for _, candidate := range normalized {
-      if loader.program[candidate] != nil {
+      if loader.programInventory(candidate) != nil {
+        if !loader.withinBoundary(candidate) {
+          loader.failures[failure] = "the re-export leaves the explicitly configured root"
+          return ""
+        }
         return candidate
       }
     }
     for _, candidate := range normalized {
       if loader.existsOnDisk(candidate) {
+        if !loader.withinBoundary(candidate) {
+          loader.failures[failure] = "the re-export leaves the explicitly configured root"
+          return ""
+        }
         return candidate
       }
     }
@@ -169,9 +242,83 @@ func (loader *typeScriptLoader) resolveUncached(
   if strings.HasPrefix(specifier, "/") {
     return ""
   }
+  if loader.boundary != nil {
+    loader.failures[failure] = "a package re-export is outside the explicitly configured root"
+    return ""
+  }
   return loader.resolvePackage(specifier)
 }
 
+type typeScriptModuleIdentity struct {
+  Path     string
+  Resolved bool
+}
+
+// Module identity follows directory links and file symlinks, while displayed
+// paths and published module addresses retain their authored spellings.
+// Cache once per evaluation so rooted populations share this filesystem work.
+func (loader *typeScriptLoader) moduleIdentity(module string) (string, bool) {
+  module = loader.projectPath(module)
+  if cached, exists := loader.identities[module]; exists {
+    return cached.Path, cached.Resolved
+  }
+  absolute := resolveProjectPath(loader.root, module)
+  resolved, ok := physicalTypeScriptPath(absolute)
+  // Resolve both sides before taking a relative identity. Canonicalizing only
+  // the file makes a project junction or Windows 8.3 root leak the checkout's
+  // absolute location into every unit ID and invalidate unchanged reviews.
+  identity := projectRelativeDisplay(loader.identityRoot, resolved)
+  loader.identities[module] = typeScriptModuleIdentity{Path: identity, Resolved: ok}
+  return identity, ok
+}
+
+func physicalTypeScriptPath(absolute string) (string, bool) {
+  current := filepath.Clean(absolute)
+  // A directory link can introduce another link in an already-walked parent.
+  // Settle the complete path, with the same finite bound as directory chains.
+  for range 32 {
+    resolved, ok := resolveLinkedPath(current)
+    if !ok {
+      return resolved, false
+    }
+    resolved = expandTypeScriptPath(resolved)
+    if resolved == current {
+      return resolved, true
+    }
+    current = resolved
+  }
+  return current, false
+}
+
+// An unsaved or deleted file still has an identity. Expand the deepest existing
+// prefix so Windows short names do not reappear when EvalSymlinks cannot read
+// the complete path, then restore the missing suffix without changing its case.
+func expandTypeScriptPath(absolute string) string {
+  probe := absolute
+  suffix := []string{}
+  for {
+    if final, err := filepath.EvalSymlinks(probe); err == nil {
+      if !strings.EqualFold(final, probe) {
+        probe = final
+      }
+      for index := len(suffix) - 1; index >= 0; index-- {
+        probe = filepath.Join(probe, suffix[index])
+      }
+      return probe
+    }
+    parent := filepath.Dir(probe)
+    if parent == probe {
+      return absolute
+    }
+    suffix = append(suffix, filepath.Base(probe))
+    probe = parent
+  }
+}
+
+func typeScriptModuleAddress(display string, identity string) artifactAddress {
+  return artifactAddress{Base: populationBase{Default: true}, Relative: identity, Display: display, Key: identity}
+}
+
 // projectPath gives every Program source and module candidate one identity
 // relative to the ttsc project. A rooted claim may name the same physical file
 // through `../api`, while an import can arrive there through a different

package/native/model.go

@@ -93,9 +93,12 @@ type referenceSpec struct {
   Type     artifactKind
   Policy   referencePolicy
   Root     string
-  Base     populationBase
-  Files    globSet
-  Source   string
+  // Rooted preserves explicit disk-loading opt-in even when '.' normalizes
+  // to the empty spelling of the project root.
+  Rooted bool
+  Base   populationBase
+  Files  globSet
+  Source string
   // Package moves the base that Files resolves against from the project to an
   // installed package. With no globs it also becomes the selection itself: the
   // package's declaration entry defines the population by reachability, while
@@ -333,6 +336,8 @@ func (declaration *evidenceDeclaration) valid() bool {
 }
 
 type artifactInventory struct {
+  // Source supplies declaration diagnostics and the active editor snapshot.
+  Source *shimast.SourceFile
   // Address is the population-relative identity used for units and
   // declarations. It differs from Path when a configured root moves the
   // address space while a diagnostic keeps naming the file the way a reader
@@ -449,6 +454,8 @@ type claimState struct {
 }
 
 type referenceState struct {
+  // Code resolves finite accessor paths independently of population traversal.
+  Code   *typeScriptExportResolver
   Spec   referenceSpec
   Paths  []string
   Units  []*evidenceUnit

package/native/rooted_typescript.go

@@ -0,0 +1,116 @@
+package evidence
+
+import (
+  "io/fs"
+  "os"
+  "path/filepath"
+  "sort"
+  "strings"
+)
+
+// A rooted reference selects entries from disk and follows their exports only
+// inside its declared root. Ordinary imports do not expand the population.
+func materializeRootedTypeScriptReference(claim claimSpec, reference referenceSpec, loader *typeScriptLoader) (referenceState, []string) {
+  state := referenceState{Spec: reference, Healthy: false, UnitsByScope: map[string][]*evidenceUnit{}}
+  context := claimLabel(claim) + " " + referenceLabel(reference)
+  base := reference.Base
+  if info, err := os.Stat(base.Absolute); err != nil || !info.IsDir() {
+    cause := "the path names a file"
+    if err != nil {
+      cause = causeText(err)
+    }
+    return state, []string{context + " could not read TypeScript reference root '" + populationRootLabel(base) + "': " + cause + ". Select an existing readable directory containing the reference files."}
+  }
+  from, resolved := resolvedBaseDirectory(base)
+  if !resolved {
+    return state, []string{unresolvedBaseProblem(base, artifactTypeScript)}
+  }
+  from, resolved = physicalTypeScriptPath(from)
+  if !resolved {
+    return state, []string{unresolvedBaseProblem(base, artifactTypeScript)}
+  }
+  entries := map[string]bool{}
+  problems := []string{}
+  err := filepath.WalkDir(from, func(current string, entry fs.DirEntry, walkErr error) error {
+    if walkErr != nil {
+      return walkErr
+    }
+    relative, err := filepath.Rel(from, current)
+    if err != nil {
+      return err
+    }
+    relative = filepath.ToSlash(relative)
+    if entry.IsDir() {
+      if relative != "." && (entry.Name() == "node_modules" || !reference.Files.couldMatchDescendant(relative)) {
+        return filepath.SkipDir
+      }
+      return nil
+    }
+    if isTypeScriptPath(relative) && reference.Files.matches(relative) {
+      entries[loader.projectPath(base.display(relative))] = true
+    }
+    return nil
+  })
+  if err != nil {
+    problems = append(problems, context+" could not list TypeScript root '"+populationRootLabel(base)+"': "+causeText(err)+". Restore filesystem access before evaluating coverage.")
+  }
+  // An open Program snapshot can precede its first save. It is authoritative
+  // on the same terms as an edited file that already exists on disk.
+  for module := range loader.program {
+    identity, resolved := loader.moduleIdentity(module)
+    if !resolved {
+      continue
+    }
+    relative, ok := relativeProjectPath(from, resolveProjectPath(loader.identityRoot, identity))
+    if ok && reference.Files.matches(relative) {
+      entries[loader.projectPath(base.display(relative))] = true
+    }
+  }
+  for entry := range entries {
+    state.Paths = append(state.Paths, entry)
+  }
+  sort.Strings(state.Paths)
+  confined := *loader
+  confined.boundary = &base
+  confined.resolved = map[string]string{}
+  confined.failures = map[string]string{}
+  population := materializeEntryUnits(&confined, state.Paths, reference.Symbols)
+  state.Units, state.Hidden, state.Published = population.Units, population.Hidden, population.Published
+  state.Code = population.Code
+  applyTraversedScopes(&state, population.Reached)
+  failed := []string{}
+  for module := range confined.failures {
+    failed = append(failed, module)
+  }
+  sort.Strings(failed)
+  for _, module := range failed {
+    problems = append(problems, context+" could not load TypeScript module '"+module+"': "+confined.failures[module]+". Repair the export or explicitly select a root containing its implementation.")
+  }
+  state.Healthy = len(problems) == 0
+  if !state.Healthy {
+    return state, problems
+  }
+  if len(state.Paths) == 0 {
+    return state, []string{context + " matched no typescript files for " + describePopulation(base, reference.Files) + ". Correct the configured root and files."}
+  }
+  if len(state.Units) == 0 {
+    return state, []string{context + " found no selected evidence units (" + reference.Symbols.names() + "). Select symbol kinds present in its exported declarations."}
+  }
+  return state, nil
+}
+
+func (loader *typeScriptLoader) withinBoundary(module string) bool {
+  if loader.boundary == nil {
+    return true
+  }
+  base, baseOK := loader.moduleIdentity(loader.boundary.Absolute)
+  source, sourceOK := loader.moduleIdentity(module)
+  if !baseOK || !sourceOK {
+    return false
+  }
+  relative, ok := relativeProjectPath(resolveProjectPath(loader.identityRoot, base), resolveProjectPath(loader.identityRoot, source))
+  if !ok || strings.Contains("/"+relative+"/", "/node_modules/") {
+    return false
+  }
+  return true
+}

package/native/typescript.go

@@ -71,11 +71,8 @@ func extendTypeScriptInventories(
 // three kinds converge: health alone now decides that the claim stays active,
 // and the population it names is the one the author has to repair.
 //
-// Only claim bases can reach a declared root here. A TypeScript reference selects
-// the active program with `files` or an installed package with `package` and is
-// refused a `root` outright, so every reference base of this kind is the default
-// one, which this pass leaves alone: `baseDirectoryProblem` returns on it, and
-// the resolver question below is asked only of a root someone declared.
+// Check passes claim populations here. Rooted references validate their disk
+// directories after claim activation in materializeRootedTypeScriptReference.
 func typeScriptBaseProblems(
   config graphConfig,
   inventories map[string]*artifactInventory,
@@ -245,6 +242,7 @@ func scanTypeScriptInventoryAt(
   file *shimast.SourceFile,
 ) *artifactInventory {
   inventory := &artifactInventory{
+    Source:      file,
     Address:     address.Key,
     Path:        address.Display,
     Type:        artifactTypeScript,
@@ -528,7 +526,7 @@ func collectTypeScriptStatements(
       if typeOnlyProjection {
         continue
       }
-      name := declarationName(statement.Name())
+      name := typeScriptDeclarationName(statement)
       if name == "" {
         continue
       }
@@ -583,7 +581,7 @@ func collectTypeScriptStatements(
         addTypeScriptHost(supportedHosts, statement, symbol)
       }
     case shimast.KindClassDeclaration:
-      name := declarationName(statement.Name())
+      name := typeScriptDeclarationName(statement)
       if name == "" {
         continue
       }
@@ -1377,7 +1375,7 @@ func collectHiddenDeclarationNames(
     if statement == nil {
       continue
     }
-    name := declarationName(statement.Name())
+    name := typeScriptDeclarationName(statement)
     if name == "" {
       continue
     }
@@ -1701,6 +1699,12 @@ func walkTypeScriptNode(node *shimast.Node, visit func(*shimast.Node)) {
 type exportedName struct {
   Public   string
   TypeOnly bool
+  // IdentityOnly materializes a default's local declaration without
+  // publishing its binding as a named export.
+  IdentityOnly bool
+  // ValueIdentity retains the value side needed by a default alias while
+  // TypeOnly still describes this named export's public restriction.
+  ValueIdentity bool
 }
 
 func collectLocalExportNames(
@@ -1748,6 +1752,21 @@ func collectLocalExportNames(
       })
     }
   }
+  for local, binding := range collectDefaultExportBindings(statements) {
+    if len(exports[local]) == 0 {
+      binding.IdentityOnly = true
+      exports[local] = []exportedName{binding}
+    } else if !binding.TypeOnly {
+      selected := 0
+      for index, name := range exports[local] {
+        current := exports[local][selected]
+        if current.TypeOnly && !name.TypeOnly || current.TypeOnly == name.TypeOnly && name.Public < current.Public {
+          selected = index
+        }
+      }
+      exports[local][selected].ValueIdentity = true
+    }
+  }
   return exports
 }
 
@@ -1787,6 +1806,9 @@ func publicTypeScriptExports(
     names[local] = exportedName{Public: local}
   }
   for _, exported := range exports[local] {
+    if exported.ValueIdentity {
+      exported.TypeOnly = false
+    }
     if exported.TypeOnly && !allowTypeOnly {
       continue
     }
@@ -1820,9 +1842,6 @@ func declarationName(node *shimast.Node) string {
     shimast.KindStringLiteral,
     shimast.KindNumericLiteral:
     name := node.Text()
-    if containsWhitespace(name) {
-      return ""
-    }
     return name
   default:
     return ""

package/native/typescript_cache.go

@@ -29,11 +29,12 @@ import (
 // depend on the hit.
 var typeScriptInventories = newTypeScriptInventoryCache()
 
-// typeScriptInventoryKey identifies one scan. The address is part of it because
-// one physical file can be addressed differently under two configured roots,
-// and the address is baked into every unit identity the scan produces.
+// typeScriptInventoryKey identifies one scan. Both the unit address and display
+// path belong to its result. Root aliases can share unit IDs while a file has
+// different project-relative paths; reusing the old path can read another file.
 type typeScriptInventoryKey struct {
   address string
+  display string
   file    *shimast.SourceFile
 }
 
@@ -69,7 +70,7 @@ func (cache *typeScriptInventoryCache) scan(
   if cache == nil || file == nil {
     return scanTypeScriptInventoryAt(address, file)
   }
-  key := typeScriptInventoryKey{address: address.Key, file: file}
+  key := typeScriptInventoryKey{address: address.Key, display: address.Display, file: file}
   cache.mutex.Lock()
   if inventory, hit := cache.live[key]; hit {
     cache.mutex.Unlock()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/evidence",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "description": "Evidence-graph lint contributor for @ttsc/lint: declare provenance with a JSDoc @evidence tag and fail the build when it is missing or dangling.",
   "main": "lib/index.js",
   "exports": {
@@ -48,13 +48,13 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.29.0",
-    "@ttsc/lint": "0.29.0"
+    "@ttsc/lint": "0.30.1",
+    "ttsc": "0.30.1"
   },
   "dependencies": {
     "@prisma/prisma-schema-wasm": "7.10.0-2.d0368e25c88e68caa4d283b5f2d88d1b76ed9356",
-    "@typia/interface": "14.0.0",
-    "@typia/utils": "14.0.0",
+    "@typia/interface": "^14.0.6",
+    "@typia/utils": "^14.0.6",
     "yaml": "^2.9.0"
   },
   "homepage": "https://ttsc.dev",