@ttsc/evidence 0.28.6 → 0.30.0

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/severity.go

@@ -0,0 +1,156 @@
+package evidence
+
+import (
+  "encoding/json"
+  "sort"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
+)
+
+func decodeGraphSeverity(raw json.RawMessage, path string) (*rule.Severity, []string) {
+  if len(raw) == 0 {
+    return nil, nil
+  }
+  var severity rule.Severity
+  var value any
+  if err := json.Unmarshal(raw, &value); err != nil {
+    return nil, []string{"Invalid evidence/graph configuration at " + path + ": expected a lint severity value."}
+  }
+  switch value {
+  case "off", float64(0):
+    severity = rule.SeverityOff
+  case "warning", "warn", float64(1):
+    severity = rule.SeverityWarn
+  case "error", float64(2):
+    severity = rule.SeverityError
+  default:
+    return nil, []string{"Invalid evidence/graph configuration at " + path + ": expected 'off', 'warning', 'warn', 'error', 0, 1, or 2; omit severity or use undefined to inherit the enclosing level."}
+  }
+  return &severity, nil
+}
+
+// Resolve inheritance once, before populations are loaded. A nil severity is
+// unset; an explicit zero disables its population.
+func resolveGraphSeverities(config *graphConfig, severity rule.Severity) {
+  for i := range config.Claims {
+    claim := &config.Claims[i]
+    claim.Level = severity
+    if claim.Severity != nil {
+      claim.Level = *claim.Severity
+    }
+    for j := range claim.References {
+      reference := &claim.References[j]
+      reference.Level = claim.Level
+      if reference.Severity != nil {
+        reference.Level = *reference.Severity
+      }
+    }
+  }
+}
+
+type graphDiagnostic struct {
+  Message  string
+  Severity rule.Severity
+}
+
+type graphDiagnostics []graphDiagnostic
+
+func (problems graphDiagnostics) add(severity rule.Severity, messages ...string) graphDiagnostics {
+  for _, message := range messages {
+    problems = append(problems, graphDiagnostic{Message: message, Severity: severity})
+  }
+  return problems
+}
+
+func (problems graphDiagnostics) report(ctx *rule.ProjectContext) {
+  levels := map[string]rule.Severity{}
+  for _, problem := range problems {
+    levels[problem.Message] = max(levels[problem.Message], problem.Severity)
+  }
+  messages := make([]string, 0, len(levels))
+  for message := range levels {
+    messages = append(messages, message)
+  }
+  sort.Strings(messages)
+  for _, message := range messages {
+    ctx.ReportSeverity(levels[message], message)
+  }
+}
+
+// A shared source problem belongs to every population that reads it. Keep the
+// strongest owning level without pooling independent coverage obligations.
+func populationSeverity(config graphConfig, kind artifactKind, base populationBase, path string, symbol string, descendants bool) rule.Severity {
+  var severity rule.Severity
+  matches := func(candidate populationBase, files globSet, symbols symbolSet) bool {
+    return candidate.Absolute == base.Absolute &&
+      (path == "" || files.matches(path) || descendants && files.couldMatchDescendant(path)) &&
+      (symbol == "*" || symbols.contains(symbol))
+  }
+  for _, claim := range config.Claims {
+    if claim.Type == kind && matches(claim.Base, claim.Files, claim.Symbols) {
+      severity = max(severity, claim.Level)
+    }
+    for _, reference := range claim.References {
+      if reference.Type == kind && reference.Package == "" && matches(reference.Base, reference.Files, reference.Symbols) {
+        severity = max(severity, reference.Level)
+      }
+    }
+  }
+  return severity
+}
+
+func artifactSeverity(config graphConfig, kind artifactKind) rule.Severity {
+  var severity rule.Severity
+  for _, claim := range config.Claims {
+    if claim.Type == kind {
+      severity = max(severity, claim.Level)
+    }
+    for _, reference := range claim.References {
+      if reference.Type == kind {
+        severity = max(severity, reference.Level)
+      }
+    }
+  }
+  return severity
+}
+
+func swaggerSeverity(config graphConfig, source string) rule.Severity {
+  var severity rule.Severity
+  for _, claim := range config.Claims {
+    for _, reference := range claim.References {
+      if reference.Type == artifactSwagger && reference.Source == source {
+        severity = max(severity, reference.Level)
+      }
+    }
+  }
+  return severity
+}
+
+func ownerSeverity(owners []claimState) rule.Severity {
+  var severity rule.Severity
+  for _, owner := range owners {
+    severity = max(severity, owner.Spec.Level)
+  }
+  return severity
+}
+
+func inventorySeverity(config graphConfig, kind artifactKind, address string, symbol string) rule.Severity {
+  var severity rule.Severity
+  for _, base := range configuredBases(config, kind) {
+    if relative, ok := base.relativeOf(address); ok {
+      severity = max(severity, populationSeverity(config, kind, base, relative, symbol, false))
+    }
+  }
+  return severity
+}
+
+// Empty or failed populations contribute no file to the shared Prisma parse.
+func prismaSetSeverity(config graphConfig, inventories map[string]*artifactInventory) rule.Severity {
+  var severity rule.Severity
+  for address, inventory := range inventories {
+    if inventory != nil && inventory.FailureBase == "" {
+      severity = max(severity, inventorySeverity(config, artifactPrisma, address, "*"))
+    }
+  }
+  return severity
+}

package/native/swagger.go

@@ -11,6 +11,8 @@ import (
   "sort"
   "strings"
   "time"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 const swaggerBridgeTimeout = 60 * time.Second
@@ -94,7 +96,7 @@ type swaggerOperation struct {
 func loadSwaggerInventories(
   root string,
   config graphConfig,
-) (map[string]*artifactInventory, []string) {
+) (map[string]*artifactInventory, graphDiagnostics) {
   sources := configuredSwaggerSources(config)
   inventories := map[string]*artifactInventory{}
   for _, source := range sources {
@@ -114,15 +116,16 @@ func loadSwaggerInventories(
   // TypeScript keystroke that triggers a rebuild.
   digests := swaggerContentDigests(root, sources)
   pending := []string{}
-  problems := []string{}
+  problems := graphDiagnostics{}
+  severity := artifactSeverity(config, artifactSwagger)
   for _, source := range sources {
     outcome, hit := lookupSwaggerDocument(source, digests[source])
     if !hit {
       pending = append(pending, source)
       continue
     }
-    problems = append(
-      problems,
+    problems = problems.add(
+      swaggerSeverity(config, source),
       swaggerUnitsFromOutcome(source, inventories[source], outcome)...,
     )
   }
@@ -140,30 +143,34 @@ func loadSwaggerInventories(
         inventoryProblem{Symbol: "operation", Message: message},
       )
     }
-    return inventories, append(problems, message)
+    var pendingSeverity rule.Severity
+    for _, source := range pending {
+      pendingSeverity = max(pendingSeverity, swaggerSeverity(config, source))
+    }
+    return inventories, problems.add(pendingSeverity, message)
   }
 
   seen := map[string]bool{}
   for _, document := range result.Documents {
     inventory := inventories[document.Source]
     if inventory == nil {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Evidence graph Swagger normalizer returned an unconfigured source '"+displaySwaggerSource(document.Source)+"'. Reinstall @ttsc/evidence; the native and JavaScript bridge contracts disagree.",
       )
       continue
     }
     if seen[document.Source] {
-      problems = append(
-        problems,
+      problems = problems.add(
+        swaggerSeverity(config, document.Source),
         "Evidence graph Swagger normalizer returned source '"+displaySwaggerSource(document.Source)+"' more than once. Reinstall @ttsc/evidence; the native and JavaScript bridge contracts disagree.",
       )
       continue
     }
     seen[document.Source] = true
     outcome := swaggerDocumentOutcome{Operations: document.Operations}
-    problems = append(
-      problems,
+    problems = problems.add(
+      swaggerSeverity(config, document.Source),
       swaggerUnitsFromOutcome(document.Source, inventory, outcome)...,
     )
     rememberSwaggerDocument(document.Source, document.Digest, outcome)
@@ -171,8 +178,8 @@ func loadSwaggerInventories(
   for _, problem := range result.Problems {
     inventory := inventories[problem.Source]
     if inventory == nil {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Evidence graph Swagger normalizer rejected an unconfigured source '"+displaySwaggerSource(problem.Source)+"'. Reinstall @ttsc/evidence; the native and JavaScript bridge contracts disagree.",
       )
       continue
@@ -182,8 +189,8 @@ func loadSwaggerInventories(
       Rejected: true,
       Problem:  problem.Message,
     }
-    problems = append(
-      problems,
+    problems = problems.add(
+      swaggerSeverity(config, problem.Source),
       swaggerUnitsFromOutcome(problem.Source, inventory, outcome)...,
     )
     rememberSwaggerDocument(problem.Source, problem.Digest, outcome)
@@ -198,7 +205,7 @@ func loadSwaggerInventories(
       inventories[source].Problems,
       inventoryProblem{Symbol: "operation", Message: message},
     )
-    problems = append(problems, message)
+    problems = problems.add(swaggerSeverity(config, source), message)
   }
   return inventories, problems
 }

package/native/typescript.go

@@ -71,16 +71,13 @@ 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,
-) []string {
-  problems := []string{}
+) graphDiagnostics {
+  problems := graphDiagnostics{}
   for _, base := range configuredBases(config, artifactTypeScript) {
     problem := baseDirectoryProblem(base, artifactTypeScript)
     // The stat accepts a chain of links the resolver will not finish, and this
@@ -111,7 +108,7 @@ func typeScriptBaseProblems(
       continue
     }
     recordPopulationFailure(inventories, artifactTypeScript, base)
-    problems = append(problems, problem)
+    problems = problems.add(populationSeverity(config, artifactTypeScript, base, "", "*", false), problem)
   }
   return problems
 }
@@ -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/native/unreadable.go

@@ -1,7 +1,6 @@
 package evidence
 
 import (
-  "sort"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -142,14 +141,14 @@ func readableCommentBody(comment string) string {
 func unreadableTypeScriptTags(
   inventories map[string]*artifactInventory,
   governed map[string]bool,
-) []string {
-  reported := []string{}
+  config graphConfig,
+) graphDiagnostics {
+  reported := graphDiagnostics{}
   for address, inventory := range inventories {
-    if inventory == nil || !governed[address] {
+    if inventory == nil || len(inventory.Unreadable) == 0 || !governed[address] {
       continue
     }
-    reported = append(reported, inventory.Unreadable...)
+    reported = reported.add(inventorySeverity(config, artifactTypeScript, address, "*"), inventory.Unreadable...)
   }
-  sort.Strings(reported)
   return reported
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/evidence",
-  "version": "0.28.6",
+  "version": "0.30.0",
   "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": {
@@ -42,19 +42,19 @@
     "url": "https://github.com/samchon/ttsc/issues"
   },
   "peerDependencies": {
-    "@ttsc/lint": ">=0.24.0"
+    "@ttsc/lint": ">0.28.6"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "@ttsc/lint": "0.28.6",
-    "ttsc": "0.28.6"
+    "@ttsc/lint": "0.30.0",
+    "ttsc": "0.30.0"
   },
   "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",