@ttsc/lint 0.28.0 → 0.28.2

package/linthost/compile.go

@@ -404,8 +404,8 @@ type residentRuleCache struct {
   mu       sync.Mutex
   key      string
   resolver RuleResolver
-  configs  map[string][sha256.Size]byte
-  // loads counts the evaluations this memo did not avoid.
+  configs  *residentRuleConfigSnapshot
+  // loads counts the resolver loads this memo did not avoid.
   //
   // It exists because a reuse is otherwise unobservable: a RuleResolver holds
   // maps, so it is not a comparable type and two of them cannot be asked
@@ -414,14 +414,29 @@ type residentRuleCache struct {
   loads int
 }
 
+// residentRuleConfigState is the resolver-owned description of every input a
+// resident answer depends on. Files are native JSON configs; dependencies are
+// the executable loader's full fingerprints, including cache-only package
+// files that deliberately stay out of ConfigPaths and external watch lists.
+type residentRuleConfigState struct {
+  dependencies []configDependencyFingerprint
+  files        []string
+}
+
+type residentRuleConfigSnapshot struct {
+  dependencies []configDependencyFingerprint
+  files        map[string][sha256.Size]byte
+}
+
 // acquireRules returns the loaded rule configuration, reusing the daemon's memo
-// while the files it was loaded from are unchanged.
+// while the complete state it was loaded from is unchanged.
 //
-// Validated against those files rather than trusted for the daemon's life. The
-// configuration is a file on disk that an author edits, and a rule set the user
-// has just changed is exactly what a resident consumer must not keep answering
-// from. The set is small — the config and whatever it extends — so re-hashing
-// it costs nothing beside the evaluation it avoids.
+// Native JSON configs are validated against their files. Executable configs
+// retain the loader's complete dependency fingerprints, including missing
+// resolution candidates and cache-only package files. The latter must remain
+// outside public project watch lists without becoming invisible to the resident
+// memo: an imported package edit can change the resolved rules just as surely
+// as an edit to lint.config.ts itself.
 func acquireRules(pluginsJSON, cwd, tsconfigPath string) (RuleResolver, error) {
   cache := residentRules
   if cache == nil {
@@ -457,16 +472,20 @@ func acquireRules(pluginsJSON, cwd, tsconfigPath string) (RuleResolver, error) {
   return resolver, nil
 }
 
-// hashRuleConfigs records the content of every file the resolver was built
-// from. A resolver naming none records none, and a memo with no recorded file
-// is never reused — it could not prove anything.
+// hashRuleConfigs records the complete state the resolver was built from. JSON
+// configs contribute file digests. Executable configs contribute the loader's
+// full dependency fingerprints, including missing resolution candidates,
+// directories, and cache-only package files that are not public watch inputs.
+// A resolver naming no state records nothing, and a memo with no proof is never
+// reused.
 //
-// A file written after the load began is recorded as nothing at all. Which
-// bytes the resolver was built from is unknowable once an edit lands inside the
-// evaluation window, and recording the ones readable now is the one wrong
-// answer that never corrects itself: the memo would agree with a file the
+// A native JSON file written after the load began is recorded as nothing at
+// all. Which bytes the resolver was built from is unknowable once an edit lands
+// inside the evaluation window, and recording the ones readable now is the one
+// wrong answer that never corrects itself: the memo would agree with a file the
 // resolver does not match, and every later request would pass the reuse test
-// until some further edit happened to disagree. Declining costs one reload.
+// until some further edit happened to disagree. Executable configs carry the
+// loader's own pre/post dependency proof instead. Declining costs one reload.
 //
 // After, and not "not before". A filesystem timestamp and the instant the load
 // began are read from the same clock, whose tick is coarse on Windows, so the
@@ -480,13 +499,25 @@ func acquireRules(pluginsJSON, cwd, tsconfigPath string) (RuleResolver, error) {
 // Read first and stated second, in that order. A write landing between the two
 // moves the modification time forward and is caught; stating it first would
 // leave the window the check exists to close.
-func hashRuleConfigs(resolver RuleResolver, started time.Time) map[string][sha256.Size]byte {
-  source, ok := resolver.(interface{ ConfigPaths() []string })
+func hashRuleConfigs(resolver RuleResolver, started time.Time) *residentRuleConfigSnapshot {
+  if configCacheDisabled() {
+    return nil
+  }
+  source, ok := resolver.(interface {
+    residentRuleConfigState() residentRuleConfigState
+  })
   if !ok {
     return nil
   }
-  configs := map[string][sha256.Size]byte{}
-  for _, location := range source.ConfigPaths() {
+  state := source.residentRuleConfigState()
+  if len(state.files) == 0 && len(state.dependencies) == 0 {
+    return nil
+  }
+  if !configDependencyDigestsAreCurrent(state.dependencies) {
+    return nil
+  }
+  configs := make(map[string][sha256.Size]byte, len(state.files))
+  for _, location := range state.files {
     contents, err := os.ReadFile(location)
     if err != nil {
       return nil
@@ -497,17 +528,20 @@ func hashRuleConfigs(resolver RuleResolver, started time.Time) map[string][sha25
     }
     configs[location] = sha256.Sum256(contents)
   }
-  if len(configs) == 0 {
-    return nil
+  return &residentRuleConfigSnapshot{
+    dependencies: state.dependencies,
+    files:        configs,
   }
-  return configs
 }
 
-func ruleConfigsUnchanged(configs map[string][sha256.Size]byte) bool {
-  if len(configs) == 0 {
+func ruleConfigsUnchanged(configs *residentRuleConfigSnapshot) bool {
+  if configCacheDisabled() ||
+    configs == nil ||
+    (len(configs.files) == 0 && len(configs.dependencies) == 0) ||
+    !configDependencyDigestsAreCurrent(configs.dependencies) {
     return false
   }
-  for location, recorded := range configs {
+  for location, recorded := range configs.files {
     contents, err := os.ReadFile(location)
     if err != nil || sha256.Sum256(contents) != recorded {
       return false

package/linthost/config.go

@@ -226,6 +226,16 @@ func (r boundProjectRuleResolver) ConfigDirectories() []string {
   return resolver.ConfigDirectories()
 }
 
+func (r boundProjectRuleResolver) residentRuleConfigState() residentRuleConfigState {
+  resolver, ok := r.RuleResolver.(interface {
+    residentRuleConfigState() residentRuleConfigState
+  })
+  if !ok {
+    return residentRuleConfigState{}
+  }
+  return resolver.residentRuleConfigState()
+}
+
 // ResolveRules implements RuleResolver. A flat RuleConfig has no glob scoping,
 // so every file receives the full map unchanged.
 func (c RuleConfig) ResolveRules(string) ResolvedRuleConfig {
@@ -361,10 +371,12 @@ func (r InlineRuleResolver) ResolveProjectRules(names []string) (map[string]Proj
 // ConfigEntry per file, the extends-target entries declared before the
 // extending file's own entry so local rules win on collision.
 type ConfigStore struct {
-  directories    []string
-  entries        []ConfigEntry
-  paths          []string
-  resolutionRoot string
+  cacheDependencies []configDependencyFingerprint
+  cacheFiles        []string
+  directories       []string
+  entries           []ConfigEntry
+  paths             []string
+  resolutionRoot    string
 }
 
 // ConfigPaths returns the config and extends files that produced this store.
@@ -387,6 +399,26 @@ func (s *ConfigStore) ConfigDirectories() []string {
   return append([]string(nil), s.directories...)
 }
 
+// residentRuleConfigState returns the private cache proof for the configuration
+// that produced this store. Executable configs retain their complete dependency
+// fingerprints, including package implementation files that must invalidate a
+// resident answer without becoming public project-watch inputs. JSON configs
+// retain only their own files because they have no executable module graph.
+func (s *ConfigStore) residentRuleConfigState() residentRuleConfigState {
+  if s == nil {
+    return residentRuleConfigState{}
+  }
+  dependencies := make([]configDependencyFingerprint, len(s.cacheDependencies))
+  for index, dependency := range s.cacheDependencies {
+    dependencies[index] = dependency
+    dependencies[index].Realpath = cloneConfigDependencyRealpath(dependency.Realpath)
+  }
+  return residentRuleConfigState{
+    dependencies: dependencies,
+    files:        append([]string(nil), s.cacheFiles...),
+  }
+}
+
 // RuleOptions implements the file-agnostic RuleResolver compatibility method.
 // Engine execution does not use this representative value: ResolveRules
 // carries the matching file's options. Callers that only understand the older
@@ -840,6 +872,7 @@ func collectConfigObject(store *ConfigStore, raw any, baseDir, path string, chai
     }
     appendConfigPaths(store, evaluated.dependencies)
     appendConfigDirectories(store, evaluated.dependencyDirectories)
+    appendResidentConfigEvaluation(store, location, evaluated)
     if err := collectConfigObject(store, evaluated.value, filepath.Dir(location), path+".extends", extendedChain); err != nil {
       return err
     }
@@ -1102,9 +1135,30 @@ func loadConfigResolver(
   }
   appendConfigPaths(store, evaluated.dependencies)
   appendConfigDirectories(store, evaluated.dependencyDirectories)
+  appendResidentConfigEvaluation(store, location, evaluated)
   return store, nil
 }
 
+func appendResidentConfigEvaluation(
+  store *ConfigStore,
+  location string,
+  evaluated evaluatedConfigFile,
+) {
+  if evaluated.dependenciesTracked {
+    for _, dependency := range evaluated.dependencyDigests {
+      cloned := dependency
+      cloned.Realpath = cloneConfigDependencyRealpath(dependency.Realpath)
+      store.cacheDependencies = append(store.cacheDependencies, cloned)
+    }
+    return
+  }
+  location = filepath.Clean(location)
+  if !containsPath(store.cacheFiles, location) {
+    store.cacheFiles = append(store.cacheFiles, location)
+    sort.Strings(store.cacheFiles)
+  }
+}
+
 func appendConfigPaths(store *ConfigStore, paths []string) {
   for _, location := range paths {
     location = filepath.Clean(location)
@@ -1602,17 +1656,28 @@ func configDependencyDigest(
       if err != nil {
         return "", err
       }
-      switch {
-      case info.Mode()&os.ModeSymlink != 0:
+      target := ""
+      entryPath := filepath.Join(dependency.Path, entry.Name())
+      if linked, linkErr := os.Readlink(entryPath); linkErr == nil {
+        // Node reports Windows junctions as symbolic links even though Go's
+        // FileMode does not carry ModeSymlink for the same reparse point. The
+        // loader writes Node's classification, so validation must ask the link
+        // itself before falling back to FileMode or an unchanged junction will
+        // make every cache lookup miss.
         kind = "symlink"
-      case info.IsDir():
-        kind = "directory"
-      case info.Mode().IsRegular():
-        kind = "file"
+        target = linked
+      } else {
+        switch {
+        case info.Mode()&os.ModeSymlink != 0:
+          kind = "symlink"
+        case info.IsDir():
+          kind = "directory"
+        case info.Mode().IsRegular():
+          kind = "file"
+        }
       }
-      target := ""
-      if kind == "symlink" {
-        target, err = os.Readlink(filepath.Join(dependency.Path, entry.Name()))
+      if kind == "symlink" && target == "" {
+        target, err = os.Readlink(entryPath)
         if err != nil {
           target = "<unreadable>"
         }
@@ -1633,6 +1698,14 @@ func configDependencyDigest(
   // script writes the fingerprint and this function is what later decides the
   // cached evaluation is still current.
   if dependency.Kind == configDependencyEntry {
+    if target, err := os.Readlink(dependency.Path); err == nil {
+      // Keep the entry form in the same Windows-junction vocabulary as the
+      // directory form above and the Node loader that produced the digest.
+      h := sha256.New()
+      h.Write([]byte("symlink\x00"))
+      h.Write([]byte(target))
+      return hex.EncodeToString(h.Sum(nil)), nil
+    }
     info, err := os.Lstat(dependency.Path)
     if err != nil {
       digest := sha256.Sum256([]byte("missing\x00"))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.28.0",
+  "version": "0.28.2",
   "description": "Reference ttsc plugin: ESLint-style lint rules over the TypeScript-Go Program used by the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -37,7 +37,7 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.28.0"
+    "ttsc": "0.28.2"
   },
   "repository": {
     "type": "git",