@ttsc/evidence 0.27.0 → 0.28.0

package/native/prisma.go

@@ -146,12 +146,13 @@ func loadPrismaInventories(
       Type: artifactPrisma,
     }
   }
-  // The set is composed of physical files, deduplicated across bases. Prisma
-  // parses one schema at a time and a file listed twice is a duplicate
-  // declaration to its own parser, so two populations that reach one file
-  // through different roots must still contribute it once.
-  sources := distinctPrismaSources(addresses)
-  if len(sources) == 0 {
+  // The set is composed of physical files, deduplicated across bases by what
+  // each address is on disk. Prisma parses one schema at a time and a file
+  // listed twice is a duplicate declaration to its own parser, so two
+  // populations that reach one file through different roots contribute it
+  // once and are both served by that one parse.
+  set := distinctPrismaSources(root, addresses)
+  if len(set.Sources) == 0 {
     return inventories, problems
   }
 
@@ -159,27 +160,27 @@ 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.
-  digest := prismaContentDigest(root, sources)
+  digest := prismaContentDigest(root, set.Sources)
   if outcome, hit := prismaSchemas.lookup(digest); hit {
     return inventories, append(
       problems,
-      prismaUnitsFromOutcome(root, sources, inventories, outcome)...,
+      prismaUnitsFromOutcome(root, set, inventories, outcome)...,
     )
   }
 
-  result, err := normalizePrismaSet(root, sources)
+  result, err := normalizePrismaSet(root, set.Sources)
   if err != nil {
-    message := "Evidence graph could not run its Prisma schema loader: " + err.Error() + ". Prisma references require Node.js and a resolvable @prisma/prisma-schema-wasm."
-    return inventories, append(problems, failPrismaSet(inventories, sources, message))
+    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))
   }
 
   outcome, problem := prismaOutcomeOf(result)
   if problem != "" {
-    return inventories, append(problems, failPrismaSet(inventories, sources, problem))
+    return inventories, append(problems, failPrismaSet(inventories, set, problem))
   }
   problems = append(
     problems,
-    prismaUnitsFromOutcome(root, sources, inventories, outcome)...,
+    prismaUnitsFromOutcome(root, set, inventories, outcome)...,
   )
   rememberPrismaSchema(outcome.digest, outcome)
   return inventories, problems
@@ -234,42 +235,58 @@ func configuredPrismaAddressesWithHealth(
   failedBases := []populationBase{}
   problems := []string{}
   for _, base := range configuredBases(config, artifactPrisma) {
-    if problem := unreadableBaseProblem(base, artifactPrisma); problem != "" {
+    if problem := baseDirectoryProblem(base, artifactPrisma); problem != "" {
       problems = append(problems, problem)
       failedBases = append(failedBases, base)
       continue
     }
     baseFailed := false
-    err := filepath.WalkDir(base.Absolute, func(current string, entry fs.DirEntry, walkErr error) error {
+    from, resolved := resolvedBaseDirectory(base)
+    if !resolved {
+      problems = append(problems, unresolvedBaseProblem(base, artifactPrisma))
+      failedBases = append(failedBases, base)
+      continue
+    }
+    err := filepath.WalkDir(from, func(current string, entry fs.DirEntry, walkErr error) error {
       if walkErr != nil {
-        relative, ok := relativeProjectPath(base.Absolute, current)
-        relevant := ok &&
-          (matchesConfiguredPrismaFile(config, base, relative) ||
-            couldContainConfiguredPrisma(config, base, relative))
-        if !relevant {
-          if entry != nil && entry.IsDir() {
-            return filepath.SkipDir
-          }
-          return nil
+        // The walk root belongs to its population by construction, so a
+        // failure to list it is a failure of the population. The relevance test
+        // below is written for an entry inside the base and reached the base
+        // itself only by accident, on a decision the glob shape made;
+        // `loadMarkdownBase` records that history in full. Leaving this
+        // exemption in one walker would decide an identical filesystem state by
+        // artifact kind.
+        if current == from {
+          return walkErr
         }
-        baseFailed = true
-        problems = append(problems, "Evidence graph could not inspect '"+current+"': "+walkErr.Error()+". Fix filesystem access so configured Prisma sources can be indexed.")
-        if entry != nil && entry.IsDir() {
-          return filepath.SkipDir
+        problem, relevant := unreadableEntryProblem(
+          base,
+          from,
+          "Prisma",
+          current,
+          walkErr,
+          func(relative string) bool {
+            return matchesConfiguredPrismaFile(config, base, relative) ||
+              couldContainConfiguredPrisma(config, base, relative)
+          },
+        )
+        if relevant {
+          baseFailed = true
+          problems = append(problems, problem)
         }
-        return nil
+        return filepath.SkipDir
       }
       if entry.IsDir() {
-        if current == base.Absolute {
+        if current == from {
           return nil
         }
-        relative, ok := relativeProjectPath(base.Absolute, current)
+        relative, ok := relativeProjectPath(from, current)
         if !ok || !couldContainConfiguredPrisma(config, base, relative) {
           return filepath.SkipDir
         }
         return nil
       }
-      relative, ok := relativeProjectPath(base.Absolute, current)
+      relative, ok := relativeProjectPath(from, current)
       if !ok || !matchesConfiguredPrismaFile(config, base, relative) {
         return nil
       }
@@ -278,7 +295,7 @@ func configuredPrismaAddressesWithHealth(
     })
     if err != nil {
       baseFailed = true
-      problems = append(problems, "Evidence graph could not walk Prisma root '"+populationRootLabel(base)+"': "+err.Error()+".")
+      problems = append(problems, unlistableBaseProblem(base, "Prisma", err))
     }
     if baseFailed {
       failedBases = append(failedBases, base)
@@ -290,30 +307,133 @@ func configuredPrismaAddressesWithHealth(
   return addresses, failedBases, problems
 }
 
+// prismaSourceSet is the parser's input: one spelling per physical schema file,
+// beside every spelling the configuration reached that file by.
+//
+// Prisma parses a set, and a file handed to it twice is a duplicate declaration
+// to its own parser — so the set has to be one entry per file on disk, not one
+// per configured address. The spellings are kept because everything the parse
+// produces is addressed by the entry that was sent, while the inventories
+// waiting for it are addressed by whichever root each population reached the
+// file through.
+type prismaSourceSet struct {
+  // Sources is the ordered set handed to the parser, the digest, and the
+  // locator, one entry per physical file.
+  Sources []string
+  // Spellings maps each entry of Sources to every address display naming the
+  // same file, that entry included.
+  Spellings map[string][]string
+}
+
 // distinctPrismaSources reduces the configured addresses to the physical files
 // the parser is handed, in one stable order.
-func distinctPrismaSources(addresses []artifactAddress) []string {
+//
+// Identity is the file's own, taken from the filesystem rather than from the
+// path that named it. Two populations reach one schema through different roots
+// precisely when their spellings differ — a package rooted at its installed
+// location and at its source checkout is the layout a package manager produces
+// — so a spelling-keyed set sends that file to the parser twice and the parser
+// rejects the whole set for a model declared twice. `os.SameFile` answers for
+// the link, the junction, the hard link, and the case-insensitive volume
+// alike, none of which a comparison of two strings can see.
+//
+// A file that cannot be stat'ed stands alone under its own spelling, which is
+// the behavior every set had before identity was physical: the digest declines
+// it and the loader reports it unreadable at its own path.
+//
+// The cost is one `os.Stat` per distinct configured address, and on Windows one
+// file open beside it for each address that reaches a comparison, because
+// `os.SameFile` loads the volume and file index there through `CreateFile`
+// rather than from the stat — once per result, since the id is cached on it.
+// Against that, the digest now reads one file per physical file rather than one
+// per address, so in the very layout this exists for the reads go down as the
+// stats go up. Both are per load of this artifact kind, of which a pass
+// performs two — the claim-side populations and then the whole configuration —
+// over a set an adopter counts in files.
+func distinctPrismaSources(root string, addresses []artifactAddress) prismaSourceSet {
+  type physicalSchema struct {
+    identity  os.FileInfo
+    spellings []string
+  }
+  files := []*physicalSchema{}
   seen := map[string]bool{}
-  sources := []string{}
   for _, address := range addresses {
     if seen[address.Display] {
       continue
     }
     seen[address.Display] = true
-    sources = append(sources, address.Display)
+    identity, err := os.Stat(resolveProjectPath(root, address.Display))
+    var host *physicalSchema
+    if err == nil {
+      for _, file := range files {
+        if file.identity != nil && os.SameFile(file.identity, identity) {
+          host = file
+          break
+        }
+      }
+    }
+    if host == nil {
+      host = &physicalSchema{}
+      if err == nil {
+        host.identity = identity
+      }
+      files = append(files, host)
+    }
+    host.spellings = append(host.spellings, address.Display)
+  }
+  set := prismaSourceSet{
+    Sources:   []string{},
+    Spellings: map[string][]string{},
+  }
+  for _, file := range files {
+    // The set's own order is sorted below, but which spelling represents a
+    // file is what every unit, declaration, and diagnostic of it will be
+    // addressed by. Taking the smallest makes that choice a property of the
+    // configuration rather than of the order a walk happened to produce.
+    sort.Strings(file.spellings)
+    set.Sources = append(set.Sources, file.spellings[0])
+    set.Spellings[file.spellings[0]] = file.spellings
+  }
+  sort.Strings(set.Sources)
+  return set
+}
+
+// prismaInventoriesBySource indexes the inventories waiting on each entry of
+// the parsed set.
+//
+// This is where one parse result becomes every population's. The parse, the
+// locations, and the comment scan all speak the set's spelling; an inventory
+// speaks its own population's. Resolving the second through the first is what
+// keeps a schema reached by two roots from serving only the root that happened
+// to sort first.
+func prismaInventoriesBySource(
+  inventories map[string]*artifactInventory,
+  set prismaSourceSet,
+) map[string][]*artifactInventory {
+  byDisplay := prismaInventoriesByDisplay(inventories)
+  indexed := map[string][]*artifactInventory{}
+  for _, source := range set.Sources {
+    // Every source is the spelling of an address, and every address owns an
+    // inventory, so no entry here is empty. It is written as an unconditional
+    // fan-out rather than guarded against a state that cannot arise, because a
+    // guard over one would say the opposite of what the loader guarantees.
+    for _, spelling := range set.Spellings[source] {
+      indexed[source] = append(indexed[source], byDisplay[spelling]...)
+    }
   }
-  sort.Strings(sources)
-  return sources
+  return indexed
 }
 
-// prismaInventoriesByDisplay indexes the inventories that share one physical
-// file.
+// prismaInventoriesByDisplay indexes the inventories that share one spelling of
+// one physical file.
 //
 // Two populations reaching one schema through different roots own separate
 // inventories of it, because each answers a different set of globs — while the
 // file itself is parsed once and its models are located once. Everything derived
 // from those bytes therefore has to reach every inventory of the file rather
-// than one of them.
+// than one of them, which is what `prismaInventoriesBySource` composes on top
+// of this index; a population whose root spells the file differently is not
+// visible here.
 func prismaInventoriesByDisplay(
   inventories map[string]*artifactInventory,
 ) map[string][]*artifactInventory {
@@ -327,7 +447,8 @@ func prismaInventoriesByDisplay(
   return indexed
 }
 
-// failPrismaSet records one whole-set failure against every file of the set.
+// failPrismaSet records one whole-set failure against every inventory of every
+// file of the set.
 //
 // The symbol is `*` rather than `model`, and the difference is load-bearing. A
 // reference reads an inventory problem only when it selects that problem's
@@ -338,11 +459,11 @@ func prismaInventoriesByDisplay(
 // failure that belongs to the whole set belongs to every selector over it.
 func failPrismaSet(
   inventories map[string]*artifactInventory,
-  sources []string,
+  set prismaSourceSet,
   message string,
 ) string {
-  indexed := prismaInventoriesByDisplay(inventories)
-  for _, source := range sources {
+  indexed := prismaInventoriesBySource(inventories, set)
+  for _, source := range set.Sources {
     for _, inventory := range indexed[source] {
       inventory.Problems = append(inventory.Problems, inventoryProblem{
         Symbol:  "*",
@@ -586,7 +707,6 @@ func prismaDeclarationsFromComments(
       // nothing reads back — the same dead end the attached case just escaped.
       for _, review := range parseReviews(run.Body) {
         shared := &evidenceReview{
-          HostID:          "prisma:" + run.Path + ":file",
           SemanticHostIDs: []string{"prisma:" + run.Path + ":file"},
           Reviews:         review.Reviews,
           Type:            artifactPrisma,
@@ -664,7 +784,6 @@ func prismaDeclarationsFromComments(
     // author cannot perform.
     for _, review := range parseReviews(run.Body) {
       shared := &evidenceReview{
-        HostID:          host.ID,
         SemanticHostIDs: []string{host.ID},
         Reviews:         review.Reviews,
         Type:            artifactPrisma,
@@ -765,7 +884,7 @@ func prismaBuriedTag(trimmed string) bool {
 // the only place a location survives: a successful parse carries no positions
 // at all, while a rejection names the file and line the author has to open.
 func prismaNormalizationFailure(message string) string {
-  reason := strings.TrimSpace(message)
+  reason := causeReason(strings.TrimSpace(message))
   if reason == "" {
     reason = "the parser reported no reason"
   }

package/native/prisma_cache.go

@@ -158,47 +158,71 @@ func rememberPrismaSchema(digest string, outcome prismaSetOutcome) {
   prismaSchemas.store(digest, outcome)
 }
 
-// prismaUnitsFromOutcome rebuilds the set's units and files them under the
-// schema file each one is written in.
+// prismaUnitsFromOutcome rebuilds the set's units and files them into every
+// inventory of the schema file each one is written in.
 //
 // Units are rebuilt per cycle rather than remembered, because a unit carries
 // its location while the parsed models do not: what was cached is a property of
 // the schema, not of where its text sits.
+//
+// One unit is one pointer, shared by every population of its file rather than
+// copied per population. A copy would carry a second identity for one model,
+// and the graph keys hosts, selections, and acknowledgements by that identity —
+// so the same model would owe its obligations twice and satisfy them once. The
+// location a copy would exist to restate is the set's spelling of the file,
+// which is a path that opens.
 func prismaUnitsFromOutcome(
   root string,
-  sources []string,
+  set prismaSourceSet,
   inventories map[string]*artifactInventory,
   outcome prismaSetOutcome,
 ) []string {
   if outcome.Rejected {
     return []string{failPrismaSet(
       inventories,
-      sources,
+      set,
       prismaNormalizationFailure(outcome.Problem),
     )}
   }
-  locations, comments := locatePrismaDeclarations(root, sources)
+  locations, comments := locatePrismaDeclarations(root, set.Sources)
   fallback := ""
-  if len(sources) != 0 {
-    fallback = sources[0]
+  if len(set.Sources) != 0 {
+    fallback = set.Sources[0]
+  }
+  indexed := prismaInventoriesBySource(inventories, set)
+  // Every inventory of the set, for the unit whose file the scan could not
+  // name. Each inventory belongs to exactly one source, so this is a union
+  // rather than a merge.
+  everywhere := []*artifactInventory{}
+  for _, source := range set.Sources {
+    everywhere = append(everywhere, indexed[source]...)
   }
-  indexed := prismaInventoriesByDisplay(inventories)
   hosts := map[string]*evidenceUnit{}
   for _, model := range outcome.Models {
     for _, unit := range prismaModelUnits(model) {
       key := joinPrismaIdentity(unit.Identity)
       location, found := locations[key]
-      if !found {
+      var hosted []*artifactInventory
+      if found {
+        unit.Path = location.Path
+        unit.Line = location.Line
+        hosted = indexed[unit.Path]
+      } else {
         // Locating is subordinate: a name the scan did not find keeps a
-        // file-level location and its full participation in coverage,
-        // because every file of the set matches the globs that selected
-        // it. A missing line costs precision, never an obligation.
-        location = prismaLocation{Path: fallback}
+        // file-level location and its full participation in coverage. A
+        // missing line costs precision, never an obligation — which is why
+        // it is filed into every inventory of the set rather than into the
+        // ones that happen to spell the location it was handed. The set spans
+        // populations whose roots name its files differently and every one of
+        // them selected files of this set, so charging the unit to the first
+        // source's populations alone would drop it from the rest with nothing
+        // said. That state is reached whenever a file the digest read a moment
+        // earlier cannot be read again, which a Windows lock is enough to do.
+        unit.Path = fallback
+        hosted = everywhere
       }
-      unit.Path = location.Path
-      unit.Line = location.Line
       hosts[key] = unit
-      for _, inventory := range indexed[unit.Path] {
+      for _, inventory := range hosted {
         inventory.Units = append(inventory.Units, unit)
       }
     }

package/native/swagger.go

@@ -132,7 +132,7 @@ func loadSwaggerInventories(
 
   result, err := normalizeSwaggerSources(root, pending)
   if err != nil {
-    message := "Evidence graph could not run its Swagger normalizer: " + err.Error() + ". Swagger references require Node.js and the installed @typia/interface, @typia/utils, and yaml dependencies."
+    message := "Evidence graph could not run its Swagger normalizer: " + causeText(err) + ". Swagger references require Node.js and the installed @typia/interface, @typia/utils, and yaml dependencies."
     for _, source := range pending {
       inventories[source].LoadFailed = true
       inventories[source].Problems = append(

package/native/swagger_cache.go

@@ -262,7 +262,7 @@ func swaggerUnitsFromOutcome(
 // that trails off after a colon reads like a formatting bug rather than a
 // broken document.
 func swaggerNormalizationFailure(source string, message string) string {
-  reason := strings.TrimSpace(message)
+  reason := causeReason(strings.TrimSpace(message))
   if reason == "" {
     reason = "the normalizer reported no reason"
   }

package/native/typescript.go

@@ -32,13 +32,14 @@ func extendTypeScriptInventories(
   inventories map[string]*artifactInventory,
   governed map[string]bool,
 ) {
-  bases := configuredBases(config, artifactTypeScript)
+  bases := typeScriptMatchBases(config)
   for _, file := range sources {
     if file == nil || !isTypeScriptPath(file.FileName()) {
       continue
     }
-    for _, base := range bases {
-      relative, ok := relativeProjectPath(base.Absolute, file.FileName())
+    for _, entry := range bases {
+      base := entry.base
+      relative, ok := entry.relativeOf(file.FileName())
       if !ok || !isTypeScriptPath(relative) {
         continue
       }
@@ -54,6 +55,67 @@ func extendTypeScriptInventories(
   }
 }
 
+// typeScriptBaseProblems reports every declared TypeScript root that is not an
+// existing directory and marks the population behind it failed.
+//
+// The other two claim-capable kinds get this from their loaders: the Markdown
+// and Prisma walkers meet the root before they list anything, report it, and
+// record a population failure that suppresses the glob diagnostic as its
+// derivative. TypeScript materializes from `ctx.Sources` and walks nothing, so
+// no loader is ever in a position to notice, and the population came back
+// healthy and empty — which routed the author to `matched no typescript files`
+// and a lecture on glob syntax for a mistake that was one directory name. The
+// rule had already computed the right sentence and used it as a boolean.
+//
+// Recording the failure rather than only reporting the string is what makes the
+// 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.
+func typeScriptBaseProblems(
+  config graphConfig,
+  inventories map[string]*artifactInventory,
+) []string {
+  problems := []string{}
+  for _, base := range configuredBases(config, artifactTypeScript) {
+    problem := baseDirectoryProblem(base, artifactTypeScript)
+    // The stat accepts a chain of links the resolver will not finish, and this
+    // kind has no walk to notice it afterwards, so the gate asks here. Without
+    // it the population came back empty and the claim deactivated in silence,
+    // which is the state a linked root was repaired to remove.
+    //
+    // Only a declared root is asked. The default base is the project root the
+    // host resolved, which both entry points realpath before this rule sees it,
+    // and a Program spells its sources against the same root, so the first
+    // comparison matches and no resolution is wanted here. Refusing anyway turns
+    // a population that works into an error: measured as a graph closing at zero
+    // diagnostics becoming one refusal that fails every claim on the base nearly
+    // every project uses.
+    //
+    // A Markdown or Prisma population on that base still answers, because those
+    // walkers generate the paths they compare and a link they cannot resolve
+    // leaves them nothing to walk; a project declaring neither has nothing that
+    // reports it. A chain long enough to survive the host's own realpath is
+    // longer than the platform follows, so this is the residue of a shape
+    // production does not reach rather than a hole in what it does.
+    if problem == "" && !base.Default {
+      if _, resolved := resolvedBaseDirectory(base); !resolved {
+        problem = unresolvedBaseProblem(base, artifactTypeScript)
+      }
+    }
+    if problem == "" {
+      continue
+    }
+    recordPopulationFailure(inventories, artifactTypeScript, base)
+    problems = append(problems, problem)
+  }
+  return problems
+}
+
 // isTypeScriptPath is asked once per source file per configured base on every
 // rebuild, so it compares the suffix in place rather than lowercasing the whole
 // path into a fresh string to answer four fixed questions.
@@ -67,6 +129,56 @@ func isTypeScriptPath(path string) bool {
   return false
 }
 
+// typeScriptMatchBase pairs a configured base with the directory a Program
+// source path is measured against.
+//
+// This kind walks nothing, so the link asymmetry #1258 removed from the two
+// walkers looked like a walk problem and was left here. It is not: `os.Stat`
+// accepts a linked root as a directory, and a Program reports whatever path its
+// tsconfig resolved, so when the two disagree about the link every source fails
+// the comparison, the claim selects nothing, and it deactivates without a word.
+// Measured before the repair: a claim rooted at a junction over its own project
+// produced no diagnostic at all.
+//
+// Both spellings are tried, because the Program may report either, and the
+// address is composed from the declared base in both cases, so a source reached
+// through a link is identified exactly as it would be without one. The
+// resolution is per base and the comparison is per source, so the extra spelling
+// costs nothing where no link is involved.
+type typeScriptMatchBase struct {
+  base     populationBase
+  resolved string
+}
+
+func typeScriptMatchBases(config graphConfig) []typeScriptMatchBase {
+  bases := configuredBases(config, artifactTypeScript)
+  entries := make([]typeScriptMatchBase, 0, len(bases))
+  for _, base := range bases {
+    // An unresolved chain is reported by the gate for a declared root, and this
+    // comparison then has only the declared spelling to offer: keeping the link
+    // the resolver stopped on would spend a second comparison against a path no
+    // source can sit under, and the guard in `relativeOf` reads exactly this
+    // equality to skip it. For the default base nothing reports it here, which is
+    // the trade the gate's own comment states.
+    resolved, ok := resolvedBaseDirectory(base)
+    if !ok {
+      resolved = base.Absolute
+    }
+    entries = append(entries, typeScriptMatchBase{base: base, resolved: resolved})
+  }
+  return entries
+}
+
+func (entry typeScriptMatchBase) relativeOf(name string) (string, bool) {
+  if relative, ok := relativeProjectPath(entry.base.Absolute, name); ok {
+    return relative, true
+  }
+  if entry.resolved == entry.base.Absolute {
+    return "", false
+  }
+  return relativeProjectPath(entry.resolved, name)
+}
+
 func relativeProjectPath(root string, absolute string) (string, bool) {
   if root == "" || absolute == "" {
     return "", false
@@ -1553,7 +1665,6 @@ func collectTypeScriptDeclarations(
     // from every acknowledgement map in evaluation.
     for _, review := range parseReviews(content[entry.node.Pos():entry.node.End()]) {
       inventory.Reviews = append(inventory.Reviews, &evidenceReview{
-        HostID:          hostID,
         SemanticHostIDs: semanticHostIDs,
         Reviews:         review.Reviews,
         Type:            artifactTypeScript,
@@ -1814,18 +1925,18 @@ func recordGovernedTypeScriptFiles(
   if governed == nil {
     return
   }
-  bases := configuredBases(declared, artifactTypeScript)
+  bases := typeScriptMatchBases(declared)
   for _, file := range sources {
     if file == nil || !isTypeScriptPath(file.FileName()) {
       continue
     }
-    for _, base := range bases {
-      relative, ok := relativeProjectPath(base.Absolute, file.FileName())
+    for _, entry := range bases {
+      relative, ok := entry.relativeOf(file.FileName())
       if !ok || !isTypeScriptPath(relative) {
         continue
       }
-      if matchesConfiguredTypeScriptFile(declared, base, relative) {
-        governed[base.addressOf(relative).Key] = true
+      if matchesConfiguredTypeScriptFile(declared, entry.base, relative) {
+        governed[entry.base.addressOf(relative).Key] = true
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/evidence",
-  "version": "0.27.0",
+  "version": "0.28.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": {
@@ -48,13 +48,13 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.27.0",
-    "@ttsc/lint": "0.27.0"
+    "@ttsc/lint": "0.28.0",
+    "ttsc": "0.28.0"
   },
   "dependencies": {
     "@prisma/prisma-schema-wasm": "7.10.0-2.d0368e25c88e68caa4d283b5f2d88d1b76ed9356",
-    "@typia/interface": "13.2.0",
-    "@typia/utils": "13.2.0",
+    "@typia/interface": "14.0.0",
+    "@typia/utils": "14.0.0",
     "yaml": "^2.9.0"
   },
   "homepage": "https://ttsc.dev",