@ttsc/lint 0.23.0 → 0.24.0

package/README.md

@@ -1169,9 +1169,10 @@ type noCycles struct{}
 
 func (noCycles) Name() string { return "architecture/no-cycles" }
 func (noCycles) Check(ctx *rule.ProjectContext) {
-  // ctx.Sources is the tsconfig-selected user-source set, including an empty set.
-  // ctx.Checker is the Program checker, and ctx.Identity keeps logical and
-  // physical project paths separate.
+  // ctx.Sources is the user-source set the host read: the tsconfig file list
+  // plus every TypeScript source the Program reached through an import, and it
+  // may be empty. ctx.Checker is the Program checker, and ctx.Identity keeps
+  // logical and physical project paths separate.
   if cycle := findCycle(ctx.Sources, ctx.Checker); cycle != "" {
     ctx.Report(cycle)
   }

package/linthost/config.go

@@ -1315,6 +1315,7 @@ const (
   configDependencyWatch        = "watch"
   configDependencyFile         = "file"
   configDependencyDir          = "directory"
+  configDependencyEntry        = "entry"
   configDependencyOptionalFile = "optional-file"
 )
 
@@ -1376,7 +1377,10 @@ func loadConfigFileEvaluationWithin(
 // configCacheVersion namespaces the on-disk config cache. Bump it whenever
 // the shape of a cached config object changes so that entries written by an
 // older @ttsc/lint binary are treated as a miss rather than silently reused.
-const configCacheVersion = "v5"
+// v6 adds the `entry` dependency kind. A v5 cache records a resolution trace's
+// ancestors as directory digests, so reusing it would keep republishing the
+// filesystem root as a watch input for as long as the entry survives.
+const configCacheVersion = "v6"
 
 // configEvalCache memoizes evaluated .ts/.js lint config objects for the
 // lifetime of one process; the on-disk cache (configCacheDir) extends the
@@ -1615,6 +1619,36 @@ func configDependencyDigest(
     }
     return hex.EncodeToString(h.Sum(nil)), nil
   }
+  // The `entry` digest observes one path's own existence and link topology.
+  // It must reproduce the loader script's encoding byte for byte, because the
+  // script writes the fingerprint and this function is what later decides the
+  // cached evaluation is still current.
+  if dependency.Kind == configDependencyEntry {
+    info, err := os.Lstat(dependency.Path)
+    if err != nil {
+      digest := sha256.Sum256([]byte("missing\x00"))
+      return hex.EncodeToString(digest[:]), nil
+    }
+    if info.Mode()&os.ModeSymlink != 0 {
+      target, err := os.Readlink(dependency.Path)
+      if err != nil {
+        target = "<unreadable>"
+      }
+      h := sha256.New()
+      h.Write([]byte("symlink\x00"))
+      h.Write([]byte(target))
+      return hex.EncodeToString(h.Sum(nil)), nil
+    }
+    kind := "other"
+    switch {
+    case info.IsDir():
+      kind = "directory"
+    case info.Mode().IsRegular():
+      kind = "file"
+    }
+    digest := sha256.Sum256([]byte(kind + "\x00"))
+    return hex.EncodeToString(digest[:]), nil
+  }
   if dependency.Kind == configDependencyOptionalFile {
     info, err := os.Stat(dependency.Path)
     if err != nil || !info.Mode().IsRegular() {
@@ -1836,6 +1870,7 @@ func normalizeConfigDependencyFingerprints(
       strings.ToLower(dependency.Digest) != dependency.Digest ||
       (dependency.Kind != configDependencyFile &&
         dependency.Kind != configDependencyDir &&
+        dependency.Kind != configDependencyEntry &&
         dependency.Kind != configDependencyOptionalFile) ||
       (dependency.Scope != configDependencyCache &&
         dependency.Scope != configDependencyWatch) {
@@ -2139,6 +2174,55 @@ function recordDirectoryDependency(location, owners) {
   }
 }
 
+// Observe one path's own existence and link topology instead of enumerating the
+// directory that contains it. A resolution trace passes through ancestors it
+// does not own -- /var on macOS is a symlink whose parent is the filesystem
+// root -- and digesting that parent both reaches outside the project boundary
+// and reads the whole directory to learn one entry's state.
+// A path candidate is observed through the directory that would own a
+// competing resolution, so a sibling winning extension resolution still
+// invalidates. That reasoning is what the parent digest is for and it stays.
+//
+// It does not reach the filesystem root. The root owns no candidate this trace
+// could pick, and a resolution path routinely passes through an ancestor
+// directly beneath it -- /var on macOS is a symlink whose parent is the root --
+// so digesting the parent there enumerates the entire filesystem root on every
+// config load, outside the project boundary. Record that one ancestor instead.
+function recordAncestorDependency(parent, entry, root, owners) {
+  if (parent === root) recordEntryDependency(entry, owners);
+  else recordDirectoryDependency(parent, owners);
+}
+
+function recordEntryDependency(location, owners) {
+  recordDependency("entry", location, entryDigest(location), owners);
+}
+
+function entryDigest(location) {
+  let entry;
+  try {
+    entry = fs.lstatSync(location);
+  } catch {
+    return createHash("sha256").update("missing\0").digest("hex");
+  }
+  if (entry.isSymbolicLink()) {
+    let target;
+    try {
+      target = fs.readlinkSync(location, { encoding: "buffer" });
+    } catch {
+      target = Buffer.from("<unreadable>");
+    }
+    return createHash("sha256")
+      .update(Buffer.concat([Buffer.from("symlink\0"), target]))
+      .digest("hex");
+  }
+  const kind = entry.isDirectory()
+    ? "directory"
+    : entry.isFile()
+      ? "file"
+      : "other";
+  return createHash("sha256").update(kind + "\0").digest("hex");
+}
+
 function directoryDigest(location) {
   const entries = [];
   if (process.platform === "win32") {
@@ -2691,11 +2775,11 @@ function recordPackagePathCandidate(
     try {
       entry = fs.lstatSync(next);
     } catch {
-      recordDirectoryDependency(current, owners);
+      recordAncestorDependency(current, next, parsed.root, owners);
       return;
     }
     if (entry.isSymbolicLink()) {
-      recordDirectoryDependency(current, owners);
+      recordAncestorDependency(current, next, parsed.root, owners);
       try {
         const target = fs.readlinkSync(next);
         const remainder = components.slice(index + 1);
@@ -2717,16 +2801,20 @@ function recordPackagePathCandidate(
       }
     }
     if (index === components.length - 1) {
-      recordDirectoryDependency(isDirectory ? next : current, owners);
+      if (isDirectory) recordDirectoryDependency(next, owners);
+      else recordAncestorDependency(current, next, parsed.root, owners);
       return;
     }
     if (!isDirectory) {
-      recordDirectoryDependency(current, owners);
+      recordAncestorDependency(current, next, parsed.root, owners);
       return;
     }
     current = next;
   }
-  recordDirectoryDependency(current, owners);
+  // Reached only when the candidate resolved to the filesystem root itself,
+  // which names no package. Record its existence, not its listing.
+  if (current === parsed.root) recordEntryDependency(current, owners);
+  else recordDirectoryDependency(current, owners);
 }
 
 function modulePackageName(specifier) {
@@ -3045,7 +3133,7 @@ const resolutionRoot = path.resolve(%s);
 const CONFIG_KEYS = new Set<string>([%s]);
 const dependencies = new Map<string, {
   digest: string;
-  kind: "directory" | "file" | "optional-file";
+  kind: "directory" | "entry" | "file" | "optional-file";
   path: string;
   owners: Set<string>;
 }>();
@@ -3207,7 +3295,7 @@ function isObject(value: unknown): value is Record<string, unknown> {
 }
 
 function recordDependency(
-  kind: "directory" | "file" | "optional-file",
+  kind: "directory" | "entry" | "file" | "optional-file",
   location: string,
   digest: string,
   owners: readonly string[],
@@ -3271,6 +3359,63 @@ function recordDirectoryDependency(
   }
 }
 
+// Observe one path's own existence and link topology instead of enumerating the
+// directory that contains it. A resolution trace passes through ancestors it
+// does not own -- /var on macOS is a symlink whose parent is the filesystem
+// root -- and digesting that parent both reaches outside the project boundary
+// and reads the whole directory to learn one entry's state.
+// A path candidate is observed through the directory that would own a
+// competing resolution, so a sibling winning extension resolution still
+// invalidates. That reasoning is what the parent digest is for and it stays.
+//
+// It does not reach the filesystem root. The root owns no candidate this trace
+// could pick, and a resolution path routinely passes through an ancestor
+// directly beneath it -- /var on macOS is a symlink whose parent is the root --
+// so digesting the parent there enumerates the entire filesystem root on every
+// config load, outside the project boundary. Record that one ancestor instead.
+function recordAncestorDependency(
+  parent: string,
+  entry: string,
+  root: string,
+  owners: readonly string[],
+): void {
+  if (parent === root) recordEntryDependency(entry, owners);
+  else recordDirectoryDependency(parent, owners);
+}
+
+function recordEntryDependency(
+  location: string,
+  owners: readonly string[],
+): void {
+  recordDependency("entry", location, entryDigest(location), owners);
+}
+
+function entryDigest(location: string): string {
+  let entry: ReturnType<typeof fs.lstatSync>;
+  try {
+    entry = fs.lstatSync(location);
+  } catch {
+    return createHash("sha256").update("missing\0").digest("hex");
+  }
+  if (entry.isSymbolicLink()) {
+    let target: Buffer;
+    try {
+      target = fs.readlinkSync(location, { encoding: "buffer" });
+    } catch {
+      target = Buffer.from("<unreadable>");
+    }
+    return createHash("sha256")
+      .update(Buffer.concat([Buffer.from("symlink\0"), target]))
+      .digest("hex");
+  }
+  const kind = entry.isDirectory()
+    ? "directory"
+    : entry.isFile()
+      ? "file"
+      : "other";
+  return createHash("sha256").update(kind + "\0").digest("hex");
+}
+
 function directoryDigest(location: string): string {
   const entries: Buffer[] = [];
   if (process.platform === "win32") {
@@ -3851,11 +3996,11 @@ function recordPackagePathCandidate(
     try {
       entry = fs.lstatSync(next);
     } catch {
-      recordDirectoryDependency(current, owners);
+      recordAncestorDependency(current, next, parsed.root, owners);
       return;
     }
     if (entry.isSymbolicLink()) {
-      recordDirectoryDependency(current, owners);
+      recordAncestorDependency(current, next, parsed.root, owners);
       try {
         const target = fs.readlinkSync(next);
         const remainder = components.slice(index + 1);
@@ -3877,16 +4022,20 @@ function recordPackagePathCandidate(
       }
     }
     if (index === components.length - 1) {
-      recordDirectoryDependency(isDirectory ? next : current, owners);
+      if (isDirectory) recordDirectoryDependency(next, owners);
+      else recordAncestorDependency(current, next, parsed.root, owners);
       return;
     }
     if (!isDirectory) {
-      recordDirectoryDependency(current, owners);
+      recordAncestorDependency(current, next, parsed.root, owners);
       return;
     }
     current = next;
   }
-  recordDirectoryDependency(current, owners);
+  // Reached only when the candidate resolved to the filesystem root itself,
+  // which names no package. Record its existence, not its listing.
+  if (current === parsed.root) recordEntryDependency(current, owners);
+  else recordDirectoryDependency(current, owners);
 }
 
 function modulePackageName(specifier: string): string | undefined {
@@ -3964,7 +4113,7 @@ function realPath(location: string): string {
 
 function finalizeDependencies(): Array<{
   digest: string;
-  kind: "directory" | "file" | "optional-file";
+  kind: "directory" | "entry" | "file" | "optional-file";
   path: string;
   scope: "cache" | "watch";
 }> {

package/linthost/fix.go

@@ -83,8 +83,14 @@ func runFix(opts *subcommandOpts) int {
   // kinds of findings in one pass — no filtering needed here.
   cascadeConverged := false
   for pass := 0; pass < maxFixPasses; pass++ {
+    // Fix reads the whole lint scope because it prints diagnostics once the
+    // cascade settles, and writes only the project's own files: an imported
+    // source reaches the report below, never the disk.
     findings := prog.runLintCycle(engine)
-    fixed, err := applyFindingFixes(opts.cwd, findings)
+    fixed, err := applyFindingFixes(
+      opts.cwd,
+      prog.projectWritableFindings(findings),
+    )
     if err != nil {
       fmt.Fprintln(os.Stderr, err)
       return 3

package/linthost/format.go

@@ -68,7 +68,9 @@ func runFormat(opts *subcommandOpts) int {
   totalFixes := 0
   cascadeConverged := false
   for pass := 0; pass < maxFormatPasses; pass++ {
-    findings := prog.runLintCycle(engine)
+    // Format's cycle stays inside the project's own sources, so every finding
+    // it sees is one it may write.
+    findings := prog.runWriteScopedCycle(engine)
     fixed, err := applyFindingFixes(opts.cwd, filterFormatFindings(findings))
     if err != nil {
       fmt.Fprintln(os.Stderr, err)

package/linthost/host.go

@@ -42,6 +42,15 @@ type program struct {
   checker      *shimchecker.Checker
   identity     publicrule.ProjectIdentity
   projectCycle *projectCycle
+  // projectRoots memoizes projectSourceFileNames, which resolves every
+  // selected file's path and therefore costs filesystem work. The tsconfig
+  // selection cannot change while one program is loaded — a config edit or a
+  // new or removed file forces a full reload upstream rather than an
+  // applyChange — while every read and every write consults the set at least
+  // once per cycle, and a fix or format cascade repeats that per pass. Filled
+  // lazily under the same single-threaded assumption projectCycle already
+  // makes, and read-only to its callers.
+  projectRoots map[string]struct{}
 }
 
 type loadProgramOptions struct {
@@ -274,11 +283,38 @@ func (p *program) runProjectCycle(engine *Engine) *projectCycle {
   return p.projectCycle
 }
 
+// runLintCycle walks everything the invocation reads: the project's own sources
+// and the TypeScript it imported. Every caller here reports its findings, so a
+// source the type-check pass read must be able to produce one.
 func (p *program) runLintCycle(engine *Engine) []*Finding {
+  return p.runCycleOver(engine, p.userSourceFiles())
+}
+
+// runWriteScopedCycle walks the project's own sources alone. It serves the
+// commands that edit files and report nothing: `format` and the LSP document
+// fix and format verbs.
+//
+// Such a command must not rewrite a sibling package it merely imports, and it
+// prints no diagnostic, so a finding outside the project has nowhere to go.
+// Reading wider would spend a full walk, once per cascade pass, on findings the
+// command discards. Scope is enforced by what these commands read rather than
+// by filtering afterwards, which leaves projectWritableFindings to `fix` alone.
+func (p *program) runWriteScopedCycle(engine *Engine) []*Finding {
+  return p.runCycleOver(engine, p.projectSourceFiles())
+}
+
+// runCycleOver evaluates the project rules and the file rules over one file set,
+// memoizing the project cycle on the program so a second verb against the same
+// program does not re-evaluate a rule. The caller owns the scope decision.
+//
+// That memo makes the scope a property of the program, not of the call: the
+// first cycle fixes the population every later verb observes. One loaded
+// program therefore serves one scope, and a caller must not ask the same
+// program for both a lint cycle and a write-scoped one.
+func (p *program) runCycleOver(engine *Engine, files []*shimast.SourceFile) []*Finding {
   if p == nil || engine == nil {
     return nil
   }
-  files := p.userSourceFiles()
   if p.projectCycle == nil {
     p.projectCycle = engine.evaluateProject(p.identity, files, p.checker)
   }
@@ -348,19 +384,59 @@ func (p *program) applyChange(absPath string) bool {
   return reused
 }
 
-// userSourceFiles returns the tsconfig-selected source files the lint engine
-// owns. The tsconfig file list is the boundary: imported libraries, generated
-// output, and JSON modules may still appear in Program.SourceFiles(), but lint
-// and format should not walk them unless the project selected them as TS/JS
-// source roots.
+// userSourceFiles returns the source files the lint engine reads for one cycle:
+// the tsconfig-selected TS/JS roots plus every TypeScript source the Program
+// pulled in through an import.
+//
+// The tsconfig file list alone is not the boundary. `ttsc` type-checks a
+// first-party sibling workspace package that resolves to its own `src`, so a
+// reporting pass restricted to the file list would hold a second, narrower view
+// of the single Program the invocation loaded — the file is checked but never
+// linted, and never reaches a project rule's ctx.Sources (samchon/ttsc#1065).
+// A consumer cannot close that gap from configuration either: adding the
+// sibling to `include` also changes what the project emits.
+//
+// The widening admits authored TypeScript only — `.ts`, `.tsx`, `.mts`, `.cts`
+// that are not declaration files. Everything else stays selection-driven:
+//   - a declaration file is typings rather than authored source, and the bundled
+//     `lib.*.d.ts` set plus every published package's `.d.ts` reach
+//     Program.SourceFiles() as well;
+//   - JavaScript enters the Program only under `allowJs`, where the project's own
+//     file list already selects the JS it owns;
+//   - a JSON module carries no lint source at all.
+//
+// A project that selects any of those explicitly keeps them, exactly as before.
+// A published dependency reaches the Program through its typings, so its own
+// `.ts` sources stay out without a dependency-shaped rule here.
 func (p *program) userSourceFiles() []*shimast.SourceFile {
-  roots := p.userSourceFileNames()
+  roots := p.projectSourceFileNames()
   out := make([]*shimast.SourceFile, 0)
   for _, f := range p.tsProgram.SourceFiles() {
     if f == nil {
       continue
     }
-    if _, ok := roots[canonicalProjectPath(p.cwd, f.FileName())]; !ok {
+    if p.selectedByProject(roots, f.FileName()) {
+      out = append(out, f)
+      continue
+    }
+    if isImportedLintSourceFile(f) {
+      out = append(out, f)
+    }
+  }
+  return out
+}
+
+// projectSourceFiles returns the Program's copy of the files the tsconfig itself
+// selected — the project's own sources, the set `format` walks and the set any
+// lint write stays inside.
+func (p *program) projectSourceFiles() []*shimast.SourceFile {
+  roots := p.projectSourceFileNames()
+  out := make([]*shimast.SourceFile, 0, len(roots))
+  for _, f := range p.tsProgram.SourceFiles() {
+    if f == nil {
+      continue
+    }
+    if !p.selectedByProject(roots, f.FileName()) {
       continue
     }
     out = append(out, f)
@@ -368,15 +444,88 @@ func (p *program) userSourceFiles() []*shimast.SourceFile {
   return out
 }
 
-func (p *program) userSourceFileNames() map[string]struct{} {
+// projectSourceFileNames returns the canonical paths of the TS/JS files the
+// tsconfig itself selected, indexed under both the configured spelling and the
+// resolved one.
+//
+// This is the narrow half of the boundary above. `format` reads nothing else at
+// all, and `fix` reads wider but writes only here, because a project must not
+// rewrite a sibling package's sources merely because it imports them. See
+// projectWritableFindings.
+//
+// Both spellings are indexed because a project can be reached through a
+// junction, a symlink, or a Windows 8.3 short name, and the Program need not
+// report a file under the spelling the config used. Before the read scope
+// widened, an alias mismatch merely dropped the file from every pass. Now it
+// would leave the file readable and unwritable, turning a fixable diagnostic
+// into one `fix` refuses to touch, so ownership resolves the alias.
+func (p *program) projectSourceFileNames() map[string]struct{} {
+  if p == nil {
+    return map[string]struct{}{}
+  }
+  if p.projectRoots != nil {
+    return p.projectRoots
+  }
   out := make(map[string]struct{})
-  if p == nil || p.parsed == nil || p.parsed.ParsedConfig == nil {
-    return out
+  if p.parsed != nil && p.parsed.ParsedConfig != nil {
+    for _, fileName := range p.parsed.ParsedConfig.FileNames {
+      if !isLintSourceFileName(fileName) {
+        continue
+      }
+      absolute := absoluteProjectPath(p.cwd, fileName)
+      out[canonicalProjectPath(p.cwd, absolute)] = struct{}{}
+      out[canonicalProjectPath(p.cwd, realProjectPath(absolute))] = struct{}{}
+    }
+  }
+  p.projectRoots = out
+  return out
+}
+
+// selectedByProject reports whether the tsconfig selected fileName, resolving
+// the path only when its own spelling misses.
+//
+// Indexing both spellings above already catches the ordinary link, so this
+// fallback exists for a Program spelling that matches neither, such as a
+// Windows 8.3 short name. It costs one resolution per file the config did not
+// select, paid by the imported set on every cycle, against the rule walk those
+// same files are about to receive.
+func (p *program) selectedByProject(
+  roots map[string]struct{},
+  fileName string,
+) bool {
+  if p == nil || len(roots) == 0 {
+    return false
   }
-  for _, fileName := range p.parsed.ParsedConfig.FileNames {
-    if isLintSourceFileName(fileName) {
-      out[canonicalProjectPath(p.cwd, fileName)] = struct{}{}
+  if _, ok := roots[canonicalProjectPath(p.cwd, fileName)]; ok {
+    return true
+  }
+  resolved := realProjectPath(absoluteProjectPath(p.cwd, fileName))
+  _, ok := roots[canonicalProjectPath(p.cwd, resolved)]
+  return ok
+}
+
+// projectWritableFindings keeps the findings whose file this project may write:
+// the ones sitting in a tsconfig-selected source, dropping every edit aimed at a
+// source the Program reached only through an import.
+//
+// This is `fix`'s guard alone, because `fix` is the one command that must read
+// wider than it writes: it prints the diagnostics that survive the cascade, so
+// an imported source has to reach its report while its edit must not reach
+// disk. The package that owns the file fixes it from its own run, under its own
+// config. Commands that only write walk the narrow set to begin with. A finding
+// without a source file (a project rule's detached report) never reaches disk
+// either and is dropped with them.
+func (p *program) projectWritableFindings(findings []*Finding) []*Finding {
+  roots := p.projectSourceFileNames()
+  out := make([]*Finding, 0, len(findings))
+  for _, finding := range findings {
+    if finding == nil || finding.File == nil {
+      continue
     }
+    if !p.selectedByProject(roots, finding.File.FileName()) {
+      continue
+    }
+    out = append(out, finding)
   }
   return out
 }
@@ -388,6 +537,18 @@ func canonicalProjectPath(cwd, fileName string) string {
   return filepath.ToSlash(filepath.Clean(fileName))
 }
 
+// isImportedLintSourceFile reports whether a Program source file the tsconfig
+// did not select is authored TypeScript the lint pass must still read.
+func isImportedLintSourceFile(file *shimast.SourceFile) bool {
+  if file == nil || file.IsDeclarationFile {
+    return false
+  }
+  return isTypeScriptSourceFileName(file.FileName())
+}
+
+// isLintSourceFileName reports whether a tsconfig-selected file is a lint/format
+// source root. The project's own selection governs here, so both TypeScript and
+// JavaScript qualify: a project that lists `.js` under `allowJs` owns it.
 func isLintSourceFileName(fileName string) bool {
   switch strings.ToLower(filepath.Ext(fileName)) {
   case ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs":
@@ -397,6 +558,18 @@ func isLintSourceFileName(fileName string) bool {
   }
 }
 
+// isTypeScriptSourceFileName reports whether a path names TypeScript source.
+// `.d.ts` shares the `.ts` extension, so callers pair this with the source
+// file's IsDeclarationFile flag rather than reading the suffix twice.
+func isTypeScriptSourceFileName(fileName string) bool {
+  switch strings.ToLower(filepath.Ext(fileName)) {
+  case ".ts", ".tsx", ".mts", ".cts":
+    return true
+  default:
+    return false
+  }
+}
+
 // programDiagnostics returns the bind + semantic diagnostics for the
 // loaded program. Same surface tsgo's CLI prints when you run a regular
 // `tsgo --noEmit`.

package/linthost/lsp.go

@@ -981,7 +981,11 @@ func lspWorkspaceEditForSeededCommand(
       prog.close()
       return nil, 0
     }
-    findings := filterFindingsForPath(prog.runLintCycle(engine), tempTarget)
+    // This command edits a document, so it walks the project's own sources the
+    // way `format` does. Reading the imported TypeScript the lint cycle covers
+    // would widen nothing here: the edit is bounded to one target below, and a
+    // read-scope widening must not open a write the project never had.
+    findings := filterFindingsForPath(prog.runWriteScopedCycle(engine), tempTarget)
     prog.close()
     if opts.command == commandFormatDocument {
       findings = filterFormatFindings(findings)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "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.23.0"
+    "ttsc": "0.24.0"
   },
   "repository": {
     "type": "git",

package/rule/project.go

@@ -170,7 +170,18 @@ type ProjectReporter interface {
 }
 
 // ProjectContext contains the immutable inputs for one project-rule check.
-// Sources is a defensive copy of the Program's tsconfig-selected user sources.
+//
+// Sources is a defensive copy of the user sources the host read for this cycle:
+// the project's own tsconfig-selected files plus every TypeScript source the
+// Program pulled in through an import, minus globally ignored paths. A rule
+// that declares a population by glob therefore sees a first-party sibling
+// workspace package the same way the type-check pass does, instead of an empty
+// population that would silently report full coverage.
+//
+// A format run is the exception. It writes files and reports nothing, so it
+// walks the project's own file list alone and a rule evaluated there receives
+// that narrower population. Draw a conclusion that must hold across the
+// workspace from a lint or check run.
 type ProjectContext struct {
   Identity ProjectIdentity
   Sources  []*shimast.SourceFile