@ttsc/evidence 0.28.6 → 0.30.0

package/native/graph.go

@@ -31,6 +31,7 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
     reportProblems(ctx, problems)
     return
   }
+  resolveGraphSeverities(&config, ctx.Severity)
   config = enabledGraphConfig(config)
   if len(config.Claims) == 0 {
     cycle.Corpus = graphCorpus{Config: config}
@@ -46,6 +47,7 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
     ctx.Report("Evidence graph project root '" + root + "' is not a readable directory. Fix the ttsc project identity before evaluating evidence globs.")
     return
   }
+  diagnostics := graphDiagnostics{}
   // Every population is anchored before anything is read, so a loader, a
   // diagnostic, and the corpus the editor receives all speak of one resolved
   // base rather than each re-deriving it from the author's spelling.
@@ -68,15 +70,15 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
     root,
     claimPopulationConfig(config, artifactPrisma),
   )
-  problems = append(
-    problems,
+  diagnostics = append(
+    diagnostics,
     typeScriptBaseProblems(
       claimPopulationConfig(config, artifactTypeScript),
       typescript,
     )...,
   )
-  problems = append(problems, markdownClaimProblems...)
-  problems = append(problems, prismaClaimProblems...)
+  diagnostics = append(diagnostics, markdownClaimProblems...)
+  diagnostics = append(diagnostics, prismaClaimProblems...)
   // Governance is judged against the configuration as declared, before
   // activation drops a claim whose population materialized no unit of its
   // symbol kind. The question is whether an author put this file in a
@@ -91,10 +93,10 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
   markdown, markdownProblems := loadMarkdownInventories(root, config)
   prisma, prismaProblems := loadPrismaInventories(root, config)
   swagger, swaggerProblems := loadSwaggerInventories(root, config)
-  problems = append(problems, markdownProblems...)
-  problems = append(problems, prismaProblems...)
-  problems = append(problems, swaggerProblems...)
-  problems = append(problems, unreadableTypeScriptTags(typescript, governed)...)
+  diagnostics = append(diagnostics, markdownProblems...)
+  diagnostics = append(diagnostics, prismaProblems...)
+  diagnostics = append(diagnostics, swaggerProblems...)
+  diagnostics = append(diagnostics, unreadableTypeScriptTags(typescript, governed, declared)...)
   loader := newTypeScriptLoader(root, typescript)
   states, stateProblems := materializeClaimStates(
     config,
@@ -104,10 +106,10 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
     typescript,
     loader,
   )
-  problems = append(problems, stateProblems...)
-  problems = append(problems, evaluateEvidenceGraph(states, loader)...)
-  reportProblems(ctx, problems)
-  if len(problems) == 0 {
+  diagnostics = append(diagnostics, stateProblems...)
+  diagnostics = append(diagnostics, evaluateEvidenceGraph(states, loader)...)
+  diagnostics.report(ctx)
+  if len(diagnostics) == 0 {
     // Published only on a clean evaluation, because the host reads state
     // from a rule that passed and reporting anything marks this one failed
     // (`linthost/hints.go:147-149`, `linthost/project_engine.go:68-77`).
@@ -238,10 +240,11 @@ func materializeClaimStates(
   swagger map[string]*artifactInventory,
   typescript map[string]*artifactInventory,
   loader *typeScriptLoader,
-) ([]claimState, []string) {
+) ([]claimState, graphDiagnostics) {
   states := make([]claimState, 0, len(config.Claims))
-  problems := []string{}
+  problems := graphDiagnostics{}
   for _, claim := range config.Claims {
+    severity := claim.Level
     inventories := inventoriesOf(claim.Type, markdown, prisma, swagger, typescript)
     paths := matchingInventoryPaths(inventories, claim.Base, claim.Files)
     state := claimState{
@@ -268,8 +271,8 @@ func materializeClaimStates(
       // exclusion the claim writes, so the misspelling is reported where
       // it was made rather than as a placement finding on each tag.
       if len(carrierPaths) == 0 && len(paths) != 0 {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           claimLabel(claim)+" declares evidenceExcludeCarriers "+describePopulation(claim.Base, claim.ExclusionCarriers)+", which selects none of its "+decimal(len(paths))+" claim file(s). Point the patterns at a file this claim already selects, or drop the property to accept an exclusion anywhere in the population.",
         )
       }
@@ -346,6 +349,7 @@ func materializeClaimStates(
     }
     sortUnits(state.Hosts)
     for _, reference := range claim.References {
+      severity := reference.Level
       referenceInventories := inventoriesOf(
         reference.Type,
         markdown,
@@ -359,7 +363,7 @@ func materializeClaimStates(
           reference,
           loader,
         )
-        problems = append(problems, entryProblems...)
+        problems = problems.add(severity, entryProblems...)
         state.References = append(state.References, entryState)
         continue
       }
@@ -369,18 +373,24 @@ func materializeClaimStates(
           reference,
           loader,
         )
-        problems = append(problems, packageProblems...)
+        problems = problems.add(severity, packageProblems...)
         state.References = append(state.References, packageState)
         continue
       }
       if reference.Type == artifactTypeScript {
+        if reference.Rooted {
+          rootedState, rootedProblems := materializeRootedTypeScriptReference(claim, reference, loader)
+          problems = problems.add(severity, rootedProblems...)
+          state.References = append(state.References, rootedState)
+          continue
+        }
         localState, localProblems := materializeLocalTypeScriptReference(
           claim,
           reference,
           referenceInventories,
           loader,
         )
-        problems = append(problems, localProblems...)
+        problems = problems.add(severity, localProblems...)
         state.References = append(state.References, localState)
         continue
       }
@@ -396,13 +406,13 @@ func materializeClaimStates(
       }
       if len(referencePaths) == 0 && referenceState.Healthy {
         if reference.Type == artifactSwagger {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             claimLabel(claim)+" "+referenceLabel(reference)+" matched no swagger source for "+describeReferenceSources(reference)+". Fix the reference location; this obligation cannot materialize evidence units without a source.",
           )
         } else {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             claimLabel(claim)+" "+referenceLabel(reference)+" matched no "+string(reference.Type)+" files for "+describePopulation(reference.Base, reference.Files)+". Fix the reference globs or the root they resolve against; this obligation cannot materialize evidence units without files.",
           )
         }
@@ -477,8 +487,8 @@ func materializeClaimStates(
         len(referenceState.Units) == 0 &&
         referenceState.Healthy &&
         !selectedInventoryProblem {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           claimLabel(claim)+" "+referenceLabel(reference)+" matched "+decimal(len(referencePaths))+" file(s) but found no selected evidence units ("+reference.Symbols.names()+"). Select symbol kinds present in those files or correct the reference globs.",
         )
       }
@@ -492,8 +502,8 @@ func materializeClaimStates(
 func evaluateEvidenceGraph(
   states []claimState,
   loader *typeScriptLoader,
-) []string {
-  problems := []string{}
+) graphDiagnostics {
+  problems := graphDiagnostics{}
   targets := map[string]map[string]*evidenceUnit{}
   markdownTargets := map[string]map[string]*evidenceUnit{}
   // Scoped targets are keyed by owning file as well as name, which is what
@@ -603,26 +613,39 @@ func evaluateEvidenceGraph(
   sort.Strings(declarationIDs)
 
   resolved := map[string]string{}
+  fileLinks := indexFileLinkClaims(states, loader)
   for _, id := range declarationIDs {
+    severity := ownerSeverity(owners[id])
     declaration := declarations[id]
     context := declarationObligationContext(owners[id])
     if !declaration.valid() {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Malformed @"+string(declaration.Tag)+" declaration at "+declaration.location()+" for "+context+": target and non-empty reason are mandatory. Write '@"+string(declaration.Tag)+" <target> <reason>'."+untrueTagWarning,
       )
       continue
     }
+    if isFileLinkTarget(declaration.Target) {
+      unitID, problem := resolveFileLinkDeclaration(declaration, owners[id], loader, fileLinks, context)
+      if problem != "" {
+        problems = problems.add(severity, problem)
+      } else {
+        resolved[id] = unitID
+      }
+      continue
+    }
     if isInlineLinkTarget(declaration.Target) {
       unitID, problem := resolveInlineLinkDeclaration(
         declaration,
         loader,
         scopedTargets,
         scopedHidden,
+        fileLinks,
+        states,
         context,
       )
       if problem != "" {
-        problems = append(problems, problem)
+        problems = problems.add(severity, problem)
         continue
       }
       resolved[id] = unitID
@@ -630,8 +653,8 @@ func evaluateEvidenceGraph(
     }
     if declaration.Type == artifactTypeScript &&
       looksLikeTypeScriptTarget(declaration.Target, targets, markdownTargets) {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Unbraced TypeScript evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": a target naming a symbol is now written as an inline link, so the citing module's import is what resolves it. Write '@"+string(declaration.Tag)+" {@link "+declaration.Target+"} <reason>' and import the symbol; 'import type' is enough.",
       )
       continue
@@ -648,9 +671,9 @@ func evaluateEvidenceGraph(
     if declaration.Type != artifactTypeScript {
       addressable, code := splitCodeCandidates(candidates)
       if len(addressable) == 0 && len(code) != 0 {
-        problems = append(
-          problems,
-          "Code evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": a "+string(declaration.Type)+" claim cannot cite a TypeScript symbol, because a symbol citation resolves through the citing module's imports and this artifact has none. Invert the obligation so the code cites this artifact, or move the citation into TypeScript.",
+        problems = problems.add(
+          severity,
+          "Code evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": an unqualified symbol has no module identity in this artifact. In Markdown, write '@link <file.ts>#<Accessor> <reason>' using a path relative to this document. Otherwise move the citation to a TypeScript claim.",
         )
         continue
       }
@@ -667,14 +690,11 @@ func evaluateEvidenceGraph(
         continue
       }
       if hidden := hiddenTargets[declaration.Target]; hidden != nil {
-        problems = append(
-          problems,
-          hiddenTargetProblem(declaration, hidden, context),
-        )
+        problems = problems.add(severity, hiddenTargetProblem(declaration, hidden, context))
         continue
       }
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Unresolved evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": no configured source materializes that evidence unit. Correct the target, make one of the named references select the source unit this claim actually uses, or remove the tag when this host does not answer for that target."+untrueTagWarning,
       )
     case 1:
@@ -687,8 +707,8 @@ func evaluateEvidenceGraph(
         descriptions = append(descriptions, unit.Readable+" at "+unit.location())
       }
       sort.Strings(descriptions)
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Ambiguous evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": it matches "+strings.Join(descriptions, "; ")+". Rename or qualify the source symbols so the target has exactly one meaning.",
       )
     }
@@ -697,11 +717,13 @@ func evaluateEvidenceGraph(
   participates := map[string]bool{}
   uncertain := map[string]bool{}
   outOfScope := map[string][]string{}
+  outOfScopeLevels := map[string]rule.Severity{}
   outOfScopeSelections := map[string]symbolSet{}
   // An exclusion outside its claim's declared carriers is a placement
   // finding, not a host-kind one, so it carries its own obligations and the
   // carrier globs its message must name.
   outsideCarrier := map[string][]string{}
+  outsideCarrierLevels := map[string]rule.Severity{}
   outsideCarrierGlobs := map[string]string{}
   // A checklist tag speaking for no selected host is a non-participation
   // finding: within its reference it answers nothing, and whether that earns a
@@ -711,6 +733,7 @@ func evaluateEvidenceGraph(
   // elsewhere — so the finding is recorded here and judged after the walk,
   // when `answers` can say whether anything consumed the tag.
   unhosted := map[string][]string{}
+  unhostedLevels := map[string]rule.Severity{}
   unhostedSelections := map[string]symbolSet{}
   // answers marks a declaration that wrote at least one acknowledgement
   // ledger, or was refused as an aggregate, which is that citation's own
@@ -732,6 +755,7 @@ func evaluateEvidenceGraph(
     // reviewing reference pays nothing.
     var reviewLedgerForClaim *reviewLedger
     for _, reference := range state.References {
+      severity := reference.Spec.Level
       if !reference.Healthy {
         for _, declaration := range state.Declarations {
           uncertain[declaration.ID] = true
@@ -819,6 +843,7 @@ func evaluateEvidenceGraph(
           continue
         }
         if declaration.Tag == tagExclude && state.OutsideCarrier[declaration.ID] {
+          outsideCarrierLevels[declaration.ID] = max(outsideCarrierLevels[declaration.ID], severity)
           outsideCarrier[declaration.ID] = appendUniqueString(
             outsideCarrier[declaration.ID],
             claimLabel(state.Spec)+" "+referenceLabel(reference.Spec),
@@ -827,6 +852,7 @@ func evaluateEvidenceGraph(
           continue
         }
         if !declarationEligibleForClaim(declaration, state.Spec) {
+          outOfScopeLevels[declaration.ID] = max(outOfScopeLevels[declaration.ID], severity)
           outOfScope[declaration.ID] = appendUniqueString(
             outOfScope[declaration.ID],
             claimLabel(state.Spec)+" "+referenceLabel(reference.Spec),
@@ -849,8 +875,8 @@ func evaluateEvidenceGraph(
           continue
         }
         if declaration.Tag == tagExclude && reference.Spec.Policy.NoExclude {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Forbidden @evidenceExclude for '"+scopesByID[scopeID].Target+"' at "+declaration.location()+" in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+": noEvidenceExclude requires positive @evidence for this reference. Remove the exclusion and cite the target from a selected "+string(state.Spec.Type)+" host that answers for it."+untrueTagWarning,
           )
           continue
@@ -889,6 +915,7 @@ func evaluateEvidenceGraph(
             // answer, and a hard diagnostic here left that valid configuration
             // no placement to exist in. The end-of-run block reports the tag
             // once nothing has consumed it.
+            unhostedLevels[declaration.ID] = max(unhostedLevels[declaration.ID], severity)
             unhosted[declaration.ID] = appendUniqueString(
               unhosted[declaration.ID],
               claimLabel(state.Spec)+" "+referenceLabel(reference.Spec),
@@ -910,8 +937,8 @@ func evaluateEvidenceGraph(
           for _, unit := range covered {
             targets = append(targets, "'"+unit.Target+"'")
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Aggregate @evidence target '"+scopesByID[scopeID].Target+"' at "+declaration.location()+" in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+": this reference is a checklist, so a citation answers for the item it names, and this target names a scope containing "+decimal(len(covered))+" item(s) ("+strings.Join(targets, ", ")+") rather than one of them. Cite each item this host answers for, or write @evidenceExclude on this scope when none of it applies here."+untrueTagWarning,
           )
           for _, unit := range covered {
@@ -926,17 +953,12 @@ func evaluateEvidenceGraph(
             // Withdrawn units are absent from Population by construction, and
             // the scope composite still needs their identities so a member
             // leaving the public surface moves the fingerprint.
-            reviewScopes = newScopeIndex(
-              append(
-                append([]*evidenceUnit{}, reference.Population...),
-                reference.Hidden...,
-              ),
-            )
+            reviewScopes = referenceReviewScopes(reference, loader)
           }
           if reviewLedgerForClaim == nil {
             reviewLedgerForClaim = newReviewLedger(state.Reviews)
           }
-          problems = append(problems, reviewProblems(
+          problems = problems.add(severity, reviewProblems(
             declaration,
             scopesByID[scopeID],
             reference,
@@ -952,8 +974,8 @@ func evaluateEvidenceGraph(
             evidenceByHostAndScope[declaration.HostID] = byScope
           }
           if first := byScope[scopeID]; first != nil {
-            problems = append(
-              problems,
+            problems = problems.add(
+              severity,
               "Duplicate @evidence for '"+scopesByID[scopeID].Target+"' on the same host at "+declaration.location()+"; first declared at "+first.location()+".",
             )
           } else {
@@ -1060,14 +1082,14 @@ func evaluateEvidenceGraph(
             evidence = conflictingDeclaration
             exclusion = declaration
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Conflicting acknowledgements for '"+conflictingUnit.Target+"' in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+": @evidence at "+evidence.location()+" overlaps @evidenceExclude at "+exclusion.location()+". Delete whichever is untrue of this host."+untrueTagWarning,
           )
         }
         if duplicateExclusionUnit != nil {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Duplicate @evidenceExclude for '"+duplicateExclusionUnit.Target+"' in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+": exclusion at "+declaration.location()+" overlaps exclusion at "+firstExclusion.location()+".",
           )
         }
@@ -1084,8 +1106,8 @@ func evaluateEvidenceGraph(
           if count == 1 {
             continue
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Evidence host "+host.Readable+" at "+host.location()+" in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+" cites "+decimal(count)+" distinct selected evidence unit(s); singleEvidencePerSymbol requires exactly 1. Split this host so each unit has one that owns it, or keep positive @evidence citations on this semantic host to exactly one distinct unit.",
           )
         }
@@ -1116,8 +1138,8 @@ func evaluateEvidenceGraph(
           if reference.Spec.Policy.NoExclude {
             repair = "Do what each item requires and cite it with @evidence on this host; this reference forbids @evidenceExclude." + untrueTagWarning
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Evidence host "+host.Readable+" at "+host.location()+" in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+" has not acknowledged "+decimal(len(missing))+" of "+decimal(len(reference.Units))+" checklist item(s): "+strings.Join(missing, ", ")+". "+repair,
           )
         }
@@ -1131,8 +1153,8 @@ func evaluateEvidenceGraph(
           if reference.Spec.Policy.NoExclude {
             repair = "Cite the artifact that answers for this unit with @evidence on a selected " + string(state.Spec.Type) + " host, building that artifact first when none does; this reference forbids @evidenceExclude." + untrueTagWarning
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Missing acknowledgement for '"+unit.Target+"' ("+unit.Readable+" at "+unit.location()+") in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+". "+repair,
           )
         }
@@ -1140,14 +1162,15 @@ func evaluateEvidenceGraph(
         if !unique || hostCount <= 1 {
           continue
         }
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence unit '"+unit.Target+"' ("+unit.Readable+" at "+unit.location()+") in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+" has "+decimal(hostCount)+" distinct positive evidence host(s); uniqueEvidence allows at most 1. Keep the one selected "+string(state.Spec.Type)+" host that owns this unit and remove the other citation(s).",
         )
       }
     }
   }
   for _, id := range declarationIDs {
+    severity := ownerSeverity(owners[id])
     if resolved[id] == "" {
       continue
     }
@@ -1161,8 +1184,8 @@ func evaluateEvidenceGraph(
     // withholds its own.
     if obligations := unhosted[id]; len(obligations) != 0 &&
       !answers[id] && !uncertain[id] {
-      problems = append(
-        problems,
+      problems = problems.add(
+        unhostedLevels[id],
         "Unhosted @"+string(declaration.Tag)+" at "+declaration.location()+" for "+strings.Join(obligations, "; ")+", target '"+displayTarget(declaration.Target)+"': a checklist acknowledgement answers for one selected host of its claim, and this declaration sits on no selected host and discharges no other obligation. Move the tag onto a host of a selected kind ("+unhostedSelections[id].names()+") in a claim that owes it."+untrueTagWarning,
       )
     }
@@ -1171,8 +1194,8 @@ func evaluateEvidenceGraph(
     }
     context := declarationObligationContext(owners[id])
     if obligations := outsideCarrier[id]; len(obligations) != 0 {
-      problems = append(
-        problems,
+      problems = problems.add(
+        outsideCarrierLevels[id],
         "Misplaced @evidenceExclude at "+declaration.location()+" for "+strings.Join(obligations, "; ")+", target '"+displayTarget(declaration.Target)+"': evidenceExcludeCarriers confines this claim's exclusions to "+outsideCarrierGlobs[id]+". Move the tag there, or delete it and build what the target requires of this claim."+untrueTagWarning,
       )
       continue
@@ -1183,14 +1206,14 @@ func evaluateEvidenceGraph(
         host = "unsupported or non-exported declaration"
       }
       if declaration.Tag == tagExclude {
-        problems = append(
-          problems,
+        problems = problems.add(
+          outOfScopeLevels[id],
           "Out-of-scope @evidenceExclude carrier at "+declaration.location()+" for "+strings.Join(obligations, "; ")+", target '"+displayTarget(declaration.Target)+"': '"+host+"' is not an eligible exclusion carrier in these matching claim files. Move the exclusion to a supported public export or selected declaration host, or use a top-level unattached Prisma documentation comment.",
         )
         continue
       }
-      problems = append(
-        problems,
+      problems = problems.add(
+        outOfScopeLevels[id],
         "Out-of-scope @"+string(declaration.Tag)+" host at "+declaration.location()+" for "+strings.Join(obligations, "; ")+", target '"+displayTarget(declaration.Target)+"': host kind '"+host+"' is not selected ("+outOfScopeSelections[id].names()+") by any of these claim obligations. Move the declaration to a selected host, or widen the claim symbol selector only when it genuinely owns this target."+untrueTagWarning,
       )
       continue
@@ -1201,8 +1224,8 @@ func evaluateEvidenceGraph(
       // derive a second claim from an incomplete graph.
       continue
     }
-    problems = append(
-      problems,
+    problems = problems.add(
+      severity,
       "Non-participating @"+string(declaration.Tag)+" target '"+displayTarget(declaration.Target)+"' at "+declaration.location()+" for "+context+": the target resolves, but none of this declaration's configured references selects it. Correct the target or reference, or move the tag to an eligible host or exclusion carrier in the claim that owes it; a resolving tag must discharge at least one obligation."+untrueTagWarning,
     )
   }
@@ -1438,6 +1461,7 @@ func materializeEntryReference(
   state.Units = population.Units
   state.Hidden = population.Hidden
   state.Published = population.Published
+  state.Code = population.Code
   if failure := loader.failure(entry); failure != "" {
     state.Healthy = false
     return state, []string{
@@ -1529,6 +1553,7 @@ func materializeLocalTypeScriptReference(
   state.Units = population.Units
   state.Hidden = population.Hidden
   state.Published = population.Published
+  state.Code = population.Code
   applyTraversedScopes(&state, population.Reached)
   if !state.Healthy {
     return state, nil
@@ -1614,6 +1639,7 @@ func materializePackageGlobReference(
   state.Units = population.Units
   state.Hidden = population.Hidden
   state.Published = population.Published
+  state.Code = population.Code
   applyTraversedScopes(&state, population.Reached)
   if !state.Healthy {
     return state, problems
@@ -1681,6 +1707,8 @@ func resolveInlineLinkDeclaration(
   loader *typeScriptLoader,
   scopedTargets map[scopedTargetKey]map[string]*evidenceUnit,
   scopedHidden map[scopedTargetKey]*evidenceUnit,
+  fileLinks map[int]*fileLinkClaimIndex,
+  states []claimState,
   context string,
 ) (string, string) {
   target := inlineLinkTarget(declaration.Target)
@@ -1711,7 +1739,19 @@ func resolveInlineLinkDeclaration(
     return "", "Incomplete evidence target '" + displayTarget(declaration.Target) + "' at " + declaration.location() + " for " + context + ": a namespace import names a module rather than a unit. Name a symbol inside '" + binding.Specifier + "' that the named reference selects."
   }
   name := strings.Join(remaining, ".")
-  candidates := scopedTargets[scopedTargetKey{path: resolvedPath, target: name}]
+  identity, _ := loader.moduleIdentity(resolvedPath)
+  candidates, hidden := queryFileLinkClaims(fileLinks, states, identity, remaining, true)
+  for id, unit := range scopedTargets[scopedTargetKey{path: resolvedPath, target: name}] {
+    candidates[id] = unit
+  }
+  if len(candidates) == 0 && len(hidden) != 0 {
+    ids := make([]string, 0, len(hidden))
+    for id := range hidden {
+      ids = append(ids, id)
+    }
+    sort.Strings(ids)
+    return "", hiddenTargetProblem(declaration, hidden[ids[0]], context)
+  }
   switch len(candidates) {
   case 0:
     if hidden := scopedHidden[scopedTargetKey{

package/native/imports.go

@@ -19,6 +19,7 @@ type importBinding struct {
   Specifier string
   Imported  string
   Namespace bool
+  TypeOnly  bool
 }
 
 // collectImportBindings indexes a file's imports by the local name each binds.
@@ -52,6 +53,7 @@ func collectImportBindings(file *shimast.SourceFile) map[string]importBinding {
         Local:     name,
         Specifier: specifier,
         Imported:  "default",
+        TypeOnly:  clause.IsTypeOnly(),
       }
     }
     if clause.NamedBindings == nil {
@@ -64,6 +66,7 @@ func collectImportBindings(file *shimast.SourceFile) map[string]importBinding {
           Local:     name,
           Specifier: specifier,
           Namespace: true,
+          TypeOnly:  clause.IsTypeOnly(),
         }
       }
     case shimast.KindNamedImports:
@@ -91,6 +94,7 @@ func collectImportBindings(file *shimast.SourceFile) map[string]importBinding {
           Local:     local,
           Specifier: specifier,
           Imported:  imported,
+          TypeOnly:  clause.IsTypeOnly() || specifierNode.IsTypeOnly,
         }
       }
     }
@@ -124,19 +128,28 @@ var typeScriptModuleExtensions = []string{
 // must spell its sibling as `./x.js`, so refusing to map it back would make the
 // correct import form unresolvable.
 func moduleCandidates(base string) []string {
-  candidates := []string{base}
-  stripped := base
-  for _, emitted := range []string{".js", ".mjs", ".cjs"} {
-    if strings.HasSuffix(base, emitted) {
-      stripped = strings.TrimSuffix(base, emitted)
-      break
+  if isTypeScriptPath(base) {
+    return []string{base}
+  }
+  substitutions := map[string][]string{
+    ".js":  {".ts", ".tsx", ".d.ts"},
+    ".mjs": {".mts", ".d.mts"},
+    ".cjs": {".cts", ".d.cts"},
+  }
+  if extensions, emitted := substitutions[path.Ext(base)]; emitted {
+    stripped := strings.TrimSuffix(base, path.Ext(base))
+    candidates := make([]string, 0, len(extensions))
+    for _, extension := range extensions {
+      candidates = append(candidates, stripped+extension)
     }
+    return candidates
   }
+  candidates := []string{}
   for _, extension := range typeScriptModuleExtensions {
-    candidates = append(candidates, stripped+extension)
+    candidates = append(candidates, base+extension)
   }
   for _, extension := range typeScriptModuleExtensions {
-    candidates = append(candidates, path.Join(stripped, "index"+extension))
+    candidates = append(candidates, path.Join(base, "index"+extension))
   }
   return candidates
 }

package/native/inputs.go

@@ -35,10 +35,8 @@ func (graphRule) ProjectInputs(ctx *rule.ProjectInputContext) []rule.ProjectInpu
 // graphProjectInputs collects the external dependency of every configured
 // obligation.
 //
-// TypeScript claims and references are absent by design. Their inventories are
-// materialized from `ctx.Sources`, which is the Program the host already
-// watches, so declaring them again would ask for a second watcher on a file
-// that already has one.
+// Program sources are already watched. Rooted TypeScript references additionally
+// declare the directory containing their disk-loaded export closure.
 func graphProjectInputs(config graphConfig) []rule.ProjectInput {
   config = enabledGraphConfig(config)
   inputs := []rule.ProjectInput{}
@@ -49,6 +47,17 @@ func graphProjectInputs(config graphConfig) []rule.ProjectInput {
     }
     for _, reference := range claim.References {
       switch reference.Type {
+      case artifactTypeScript:
+        if reference.Rooted {
+          // Export traversal can reach a module outside the entry globs, and
+          // this pre-Program protocol cannot discover that closure. The root
+          // is its explicit boundary, including future files and repairs.
+          pattern := "**"
+          if reference.Root != "" {
+            pattern = strings.TrimSuffix(reference.Root, "/") + "/**"
+          }
+          inputs = append(inputs, rule.ProjectInput{Kind: rule.ProjectInputGlob, Pattern: pattern})
+        }
       case artifactMarkdown, artifactPrisma:
         inputs = append(inputs, globInputs(reference.Root, reference.Files)...)
       case artifactSwagger: