@ttsc/evidence 0.28.6 → 0.30.0

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

@@ -23,9 +23,9 @@ var explicitAnchorPattern = regexp.MustCompile(`\s*\{#([A-Za-z0-9][A-Za-z0-9._:-
 func loadMarkdownInventories(
   root string,
   config graphConfig,
-) (map[string]*artifactInventory, []string) {
+) (map[string]*artifactInventory, graphDiagnostics) {
   inventories := map[string]*artifactInventory{}
-  problems := []string{}
+  problems := graphDiagnostics{}
   for _, base := range configuredBases(config, artifactMarkdown) {
     problems = append(
       problems,
@@ -39,16 +39,17 @@ func loadMarkdownBase(
   base populationBase,
   config graphConfig,
   inventories map[string]*artifactInventory,
-) []string {
-  problems := []string{}
+) graphDiagnostics {
+  problems := graphDiagnostics{}
+  severity := populationSeverity(config, artifactMarkdown, base, "", "*", false)
   if problem := baseDirectoryProblem(base, artifactMarkdown); problem != "" {
     recordPopulationFailure(inventories, artifactMarkdown, base)
-    return []string{problem}
+    return problems.add(severity, problem)
   }
   from, resolved := resolvedBaseDirectory(base)
   if !resolved {
     recordPopulationFailure(inventories, artifactMarkdown, base)
-    return []string{unresolvedBaseProblem(base, artifactMarkdown)}
+    return problems.add(severity, unresolvedBaseProblem(base, artifactMarkdown))
   }
   err := filepath.WalkDir(from, func(current string, entry fs.DirEntry, walkErr error) error {
     if walkErr != nil {
@@ -82,7 +83,8 @@ func loadMarkdownBase(
       )
       if relevant {
         recordPopulationFailure(inventories, artifactMarkdown, base)
-        problems = append(problems, problem)
+        relative, _ := relativeProjectPath(from, current)
+        problems = problems.add(populationSeverity(config, artifactMarkdown, base, relative, "*", true), problem)
       }
       // `WalkDir` passes a nil entry only for its root, which the guard above
       // answers, so this error belongs to a directory whose listing failed and
@@ -105,6 +107,7 @@ func loadMarkdownBase(
     if !matchesConfiguredMarkdownFile(config, base, relative) {
       return nil
     }
+    severity := populationSeverity(config, artifactMarkdown, base, relative, "*", false)
     address := base.addressOf(relative)
     content, readErr := os.ReadFile(current)
     if readErr != nil {
@@ -113,26 +116,29 @@ func loadMarkdownBase(
         Type:       artifactMarkdown,
         LoadFailed: true,
       }
-      problems = append(problems, "Evidence graph could not read Markdown file '"+address.Display+"': "+causeText(readErr)+". Fix filesystem access or exclude the file from configured globs.")
+      problems = problems.add(
+        severity,
+        "Evidence graph could not read Markdown file '"+address.Display+"': "+causeText(readErr)+". Fix filesystem access or exclude the file from configured globs.",
+      )
       return nil
     }
     inventory, _ := scanMarkdownInventory(address, string(content))
     inventories[address.Key] = inventory
     for _, inventoryProblem := range inventory.Problems {
       if selectedByMarkdownPopulation(config, base, relative, inventoryProblem.Symbol) {
-        problems = append(problems, inventoryProblem.Message)
+        problems = problems.add(populationSeverity(config, artifactMarkdown, base, relative, inventoryProblem.Symbol, false), inventoryProblem.Message)
       }
     }
     // An unreadable tag is not a health question and not a symbol question
     // either: the file loaded, its units are complete, and the tag reaches no
     // host whichever symbol a reference selects. The walk already refuses a
     // path no configured glob takes, so reaching here is enough to report.
-    problems = append(problems, inventory.Unreadable...)
+    problems = problems.add(severity, inventory.Unreadable...)
     return nil
   })
   if err != nil {
     recordPopulationFailure(inventories, artifactMarkdown, base)
-    problems = append(problems, unlistableBaseProblem(base, "Markdown", err))
+    problems = problems.add(severity, unlistableBaseProblem(base, "Markdown", err))
   }
   return problems
 }

package/native/model.go

@@ -5,6 +5,7 @@ import (
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 const graphRuleName = "evidence/graph"
@@ -57,6 +58,8 @@ type graphConfig struct {
 }
 
 type claimSpec struct {
+  Severity *rule.Severity
+  Level    rule.Severity
   Index    int
   Type     artifactKind
   Name     string
@@ -84,10 +87,15 @@ type claimSpec struct {
 }
 
 type referenceSpec struct {
-  Index  int
-  Type   artifactKind
-  Policy referencePolicy
-  Root   string
+  Severity *rule.Severity
+  Level    rule.Severity
+  Index    int
+  Type     artifactKind
+  Policy   referencePolicy
+  Root     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
@@ -328,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
@@ -444,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/prisma.go

@@ -12,6 +12,8 @@ import (
   "sort"
   "strings"
   "time"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 const prismaBridgeTimeout = 60 * time.Second
@@ -127,7 +129,7 @@ type prismaField struct {
 func loadPrismaInventories(
   root string,
   config graphConfig,
-) (map[string]*artifactInventory, []string) {
+) (map[string]*artifactInventory, graphDiagnostics) {
   // A graph that names no Prisma glob never pays for one. The walk below is
   // cheap on such a project — every directory fails the descendant test and is
   // skipped at once — but "cheap" is still a full listing of the project root
@@ -160,27 +162,28 @@ func loadPrismaInventories(
   // ten-model schema and a two-hundred-model one pay nearly the same. A
   // resident host repeats this every cycle, so an unchanged schema would
   // otherwise be re-parsed on every TypeScript keystroke that rebuilds.
+  severity := prismaSetSeverity(config, inventories)
   digest := prismaContentDigest(root, set.Sources)
   if outcome, hit := prismaSchemas.lookup(digest); hit {
     return inventories, append(
       problems,
-      prismaUnitsFromOutcome(root, set, inventories, outcome)...,
+      prismaUnitsFromOutcome(root, set, inventories, outcome, config)...,
     )
   }
 
   result, err := normalizePrismaSet(root, set.Sources)
   if err != nil {
     message := "Evidence graph could not run its Prisma schema loader: " + causeText(err) + ". Prisma references require Node.js and a resolvable @prisma/prisma-schema-wasm."
-    return inventories, append(problems, failPrismaSet(inventories, set, message))
+    return inventories, problems.add(severity, failPrismaSet(inventories, set, message))
   }
 
   outcome, problem := prismaOutcomeOf(result)
   if problem != "" {
-    return inventories, append(problems, failPrismaSet(inventories, set, problem))
+    return inventories, problems.add(severity, failPrismaSet(inventories, set, problem))
   }
   problems = append(
     problems,
-    prismaUnitsFromOutcome(root, set, inventories, outcome)...,
+    prismaUnitsFromOutcome(root, set, inventories, outcome, config)...,
   )
   rememberPrismaSchema(outcome.digest, outcome)
   return inventories, problems
@@ -223,27 +226,28 @@ func prismaOutcomeOf(result prismaNormalizationResult) (prismaSetOutcome, string
 // Order is the digest's, so it must not depend on filesystem enumeration.
 func configuredPrismaAddresses(
   config graphConfig,
-) ([]artifactAddress, []string) {
+) ([]artifactAddress, graphDiagnostics) {
   addresses, _, problems := configuredPrismaAddressesWithHealth(config)
   return addresses, problems
 }
 
 func configuredPrismaAddressesWithHealth(
   config graphConfig,
-) ([]artifactAddress, []populationBase, []string) {
+) ([]artifactAddress, []populationBase, graphDiagnostics) {
   addresses := []artifactAddress{}
   failedBases := []populationBase{}
-  problems := []string{}
+  problems := graphDiagnostics{}
   for _, base := range configuredBases(config, artifactPrisma) {
+    severity := populationSeverity(config, artifactPrisma, base, "", "*", false)
     if problem := baseDirectoryProblem(base, artifactPrisma); problem != "" {
-      problems = append(problems, problem)
+      problems = problems.add(severity, problem)
       failedBases = append(failedBases, base)
       continue
     }
     baseFailed := false
     from, resolved := resolvedBaseDirectory(base)
     if !resolved {
-      problems = append(problems, unresolvedBaseProblem(base, artifactPrisma))
+      problems = problems.add(severity, unresolvedBaseProblem(base, artifactPrisma))
       failedBases = append(failedBases, base)
       continue
     }
@@ -272,7 +276,8 @@ func configuredPrismaAddressesWithHealth(
         )
         if relevant {
           baseFailed = true
-          problems = append(problems, problem)
+          relative, _ := relativeProjectPath(from, current)
+          problems = problems.add(populationSeverity(config, artifactPrisma, base, relative, "*", true), problem)
         }
         return filepath.SkipDir
       }
@@ -295,7 +300,7 @@ func configuredPrismaAddressesWithHealth(
     })
     if err != nil {
       baseFailed = true
-      problems = append(problems, unlistableBaseProblem(base, "Prisma", err))
+      problems = problems.add(severity, unlistableBaseProblem(base, "Prisma", err))
     }
     if baseFailed {
       failedBases = append(failedBases, base)
@@ -647,15 +652,17 @@ func prismaDeclarationsFromComments(
   comments []prismaCommentRun,
   hosts map[string]*evidenceUnit,
   inventories map[string][]*artifactInventory,
-) []string {
-  problems := []string{}
+  levels map[string]rule.Severity,
+) graphDiagnostics {
+  problems := graphDiagnostics{}
   sequence := 0
   for _, run := range comments {
+    severity := levels[run.Path]
     location := run.Path + ":" + decimal(run.Line)
     if run.Form != prismaDocComment {
       if prismaCommentCarriesTag(run.Body) {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence tag at "+location+" sits in a '//' line comment, which Prisma discards rather than attaching to the declaration below it. Write the citation on a '///' or '/* */' documentation comment directly above the model, column, or relation it grounds.",
         )
       }
@@ -667,8 +674,8 @@ func prismaDeclarationsFromComments(
         continue
       }
       for _, offset := range prismaBuriedTagLines(run.Body) {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence tag at "+run.Path+":"+decimal(run.Line+offset)+" is buried behind an extra slash. Prisma reads a fourth slash as content, so the tag no longer opens its documentation line and nothing resolves it. Write exactly three slashes.",
         )
       }
@@ -676,8 +683,8 @@ func prismaDeclarationsFromComments(
         sequence++
         line := run.Line + parsed.LineOffset
         if parsed.Tag == tagEvidence {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "@evidence at "+run.Path+":"+decimal(line)+" is on a file-level Prisma exclusion carrier. Move ownership evidence directly above the selected model, column, or relation it grounds; only @evidenceExclude may be unattached at file level.",
           )
           continue
@@ -724,8 +731,8 @@ func prismaDeclarationsFromComments(
     }
     if run.Key == "" {
       if prismaCommentCarriesTag(run.Body) {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence tag at "+location+" documents no declaration. Prisma attaches a '///' comment to the declaration that immediately follows it, so a blank line before a top-level block, a block attribute, or a closing brace leaves the comment documenting nothing. Move the citation directly above the model, column, or relation it grounds.",
         )
       }
@@ -734,8 +741,8 @@ func prismaDeclarationsFromComments(
     host := hosts[run.Key]
     if host == nil {
       if prismaCommentCarriesTag(run.Body) {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence tag at "+location+" documents '"+run.Key+"', which is not a model, column, or relation. A model or a view and their members host an evidence citation; an enum, a composite type, and a datasource or generator setting do not.",
         )
       }
@@ -746,8 +753,8 @@ func prismaDeclarationsFromComments(
       continue
     }
     for _, offset := range prismaBuriedTagLines(run.Body) {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Evidence tag at "+run.Path+":"+decimal(run.Line+offset)+" is buried behind an extra slash. Prisma reads a fourth slash as content, so the tag no longer opens its documentation line and nothing resolves it. Write exactly three slashes.",
       )
     }

package/native/prisma_cache.go

@@ -6,6 +6,8 @@ import (
   "os"
   "strings"
   "sync"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 // prismaCacheLimit bounds the cache so a resident host cannot grow without end.
@@ -176,13 +178,14 @@ func prismaUnitsFromOutcome(
   set prismaSourceSet,
   inventories map[string]*artifactInventory,
   outcome prismaSetOutcome,
-) []string {
+  config graphConfig,
+) graphDiagnostics {
   if outcome.Rejected {
-    return []string{failPrismaSet(
+    return graphDiagnostics{}.add(prismaSetSeverity(config, inventories), failPrismaSet(
       inventories,
       set,
       prismaNormalizationFailure(outcome.Problem),
-    )}
+    ))
   }
   locations, comments := locatePrismaDeclarations(root, set.Sources)
   fallback := ""
@@ -230,7 +233,16 @@ func prismaUnitsFromOutcome(
   for _, inventory := range inventories {
     sortUnits(inventory.Units)
   }
-  return prismaDeclarationsFromComments(comments, hosts, indexed)
+  levels := map[string]rule.Severity{}
+  for key, inventory := range inventories {
+    levels[inventory.Path] = max(levels[inventory.Path], inventorySeverity(config, artifactPrisma, key, "*"))
+  }
+  for _, source := range set.Sources {
+    for _, spelling := range set.Spellings[source] {
+      levels[source] = max(levels[source], levels[spelling])
+    }
+  }
+  return prismaDeclarationsFromComments(comments, hosts, indexed, levels)
 }
 
 // joinPrismaIdentity renders a unit's identity the way the locator keys one.