@ttsc/lint 0.26.2 → 0.28.0

package/linthost/config.go

@@ -1294,10 +1294,12 @@ func loadConfigFile(location string) (any, error) {
 }
 
 type configDependencyFingerprint struct {
-  Path   string `json:"path"`
-  Digest string `json:"digest"`
-  Kind   string `json:"kind"`
-  Scope  string `json:"scope"`
+  Path           string  `json:"path"`
+  Digest         string  `json:"digest"`
+  IdentityStable bool    `json:"identityStable"`
+  Kind           string  `json:"kind"`
+  Realpath       *string `json:"realpath"`
+  Scope          string  `json:"scope"`
 }
 
 const (
@@ -1367,10 +1369,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.
-// 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"
+// v8 also rejects content-restoring A-B-A replacement during evaluation. A v7
+// cache can otherwise pair output from the transient state with the restored
+// state's equal digest and physical path.
+const configCacheVersion = "v8"
 
 // configEvalCache memoizes evaluated .ts/.js lint config objects for the
 // lifetime of one process; the on-disk cache (configCacheDir) extends the
@@ -1557,6 +1559,10 @@ func configDependencyDigestsAreCurrent(
   dependencies []configDependencyFingerprint,
 ) bool {
   for _, dependency := range dependencies {
+    if !dependency.IdentityStable ||
+      !sameConfigDependencyRealpath(dependency.Realpath, configDependencyRealpath(dependency.Path)) {
+      return false
+    }
     digest, err := configDependencyDigest(dependency)
     if err != nil {
       return false
@@ -1568,6 +1574,19 @@ func configDependencyDigestsAreCurrent(
   return true
 }
 
+func configDependencyRealpath(location string) *string {
+  absolute, err := filepath.Abs(location)
+  if err != nil {
+    return nil
+  }
+  resolved := realProjectPath(absolute)
+  if _, statErr := os.Stat(resolved); statErr != nil {
+    return nil
+  }
+  resolved = filepath.Clean(resolved)
+  return &resolved
+}
+
 func configDependencyDigest(
   dependency configDependencyFingerprint,
 ) (string, error) {
@@ -1848,7 +1867,8 @@ func normalizeConfigDependencyFingerprints(
   for _, dependency := range input {
     if strings.TrimSpace(dependency.Path) == "" ||
       !filepath.IsAbs(dependency.Path) ||
-      len(dependency.Digest) != sha256.Size*2 ||
+      (dependency.Realpath != nil && !filepath.IsAbs(*dependency.Realpath)) ||
+      (dependency.Digest != "" && len(dependency.Digest) != sha256.Size*2) ||
       strings.ToLower(dependency.Digest) != dependency.Digest ||
       (dependency.Kind != configDependencyFile &&
         dependency.Kind != configDependencyDir &&
@@ -1858,24 +1878,30 @@ func normalizeConfigDependencyFingerprints(
         dependency.Scope != configDependencyWatch) {
       return nil, false
     }
-    if _, err := hex.DecodeString(dependency.Digest); err != nil {
-      return nil, false
+    if dependency.Digest != "" {
+      if _, err := hex.DecodeString(dependency.Digest); err != nil {
+        return nil, false
+      }
     }
     absolute := filepath.Clean(dependency.Path)
     key := dependency.Kind + "\x00" + absolute
     if previous, exists := seen[key]; exists {
       if previous.Digest != dependency.Digest ||
+        previous.IdentityStable != dependency.IdentityStable ||
         previous.Kind != dependency.Kind ||
+        !sameConfigDependencyRealpath(previous.Realpath, dependency.Realpath) ||
         previous.Scope != dependency.Scope {
         return nil, false
       }
       continue
     }
     fingerprint := configDependencyFingerprint{
-      Path:   absolute,
-      Digest: dependency.Digest,
-      Kind:   dependency.Kind,
-      Scope:  dependency.Scope,
+      Path:           absolute,
+      Digest:         dependency.Digest,
+      IdentityStable: dependency.IdentityStable,
+      Kind:           dependency.Kind,
+      Realpath:       cloneConfigDependencyRealpath(dependency.Realpath),
+      Scope:          dependency.Scope,
     }
     seen[key] = fingerprint
     normalized = append(normalized, fingerprint)
@@ -1886,6 +1912,21 @@ func normalizeConfigDependencyFingerprints(
   return normalized, true
 }
 
+func cloneConfigDependencyRealpath(value *string) *string {
+  if value == nil {
+    return nil
+  }
+  cloned := filepath.Clean(*value)
+  return &cloned
+}
+
+func sameConfigDependencyRealpath(left, right *string) bool {
+  if left == nil || right == nil {
+    return left == nil && right == nil
+  }
+  return filepath.Clean(*left) == filepath.Clean(*right)
+}
+
 // loadScriptConfigFile evaluates a .js/.cjs/.mjs config file by running a
 // Node subprocess that dynamic-imports the file, resolves the exported config
 // through the same 8-hop default/config normalization used by the TS loader,
@@ -1919,12 +1960,18 @@ func loadScriptConfigEvaluationWithin(
   cmd := exec.CommandContext(
     ctx,
     node,
-    "-e",
-    script,
+    "--input-type=commonjs",
+    "-",
     location,
     outputPath,
     resolutionRoot,
   )
+  // Windows limits the whole process command line to roughly 32 KiB. The
+  // dependency-tracking loader is intentionally larger than that, so keep only
+  // an explicit CommonJS stdin program and remove Node's stdin sentinel before
+  // the loader runs. This preserves the historical process.argv layout seen by
+  // both the loader and the imported user config without using string eval.
+  cmd.Stdin = strings.NewReader("process.argv.splice(1, 1);\n" + script)
   return runConfigLoaderCommand(cmd, location, "config file", outputPath)
 }
 
@@ -2104,19 +2151,78 @@ function isObject(value) {
   return value !== null && typeof value === "object";
 }
 
+function missingPathError(error) {
+  return error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+
+function dependencyMetadataSignature(location) {
+  const requested = path.resolve(location);
+  let current = requested;
+  for (;;) {
+    try {
+      const link = fs.lstatSync(current, { bigint: true });
+      let target = link;
+      if (link.isSymbolicLink()) {
+        try { target = fs.statSync(current, { bigint: true }); }
+        catch { return undefined; }
+      }
+      return [path.relative(current, requested), link.dev, link.ino, link.mode, link.size, link.mtimeNs, link.ctimeNs, target.dev, target.ino, target.mode, target.size, target.mtimeNs, target.ctimeNs].join(":");
+    } catch (error) {
+      if (!missingPathError(error)) return undefined;
+      const parent = path.dirname(current);
+      if (parent === current) return undefined;
+      current = parent;
+    }
+  }
+}
+
+function currentDependencyDigest(kind, location) {
+  try {
+    if (kind === "directory") return directoryDigest(location);
+    if (kind === "entry") return entryDigest(location);
+    if (kind === "optional-file") return optionalFileDigest(location);
+    return createHash("sha256").update(fs.readFileSync(location)).digest("hex");
+  } catch {
+    return "";
+  }
+}
+
 function recordDependency(kind, location, digest, owners) {
   const key = kind + "\0" + location;
   const previous = dependencies.get(key);
   const mergedOwners = previous ? previous.owners : new Set();
   for (const owner of owners) mergedOwners.add(owner);
+  const beforeSignature = dependencyMetadataSignature(location);
+  const observedDigest = currentDependencyDigest(kind, location);
+  const realpath = dependencyRealpath(location);
+  const afterSignature = dependencyMetadataSignature(location);
+  const identityStable =
+    (!previous || previous.identityStable) &&
+    beforeSignature !== undefined &&
+    afterSignature !== undefined &&
+    beforeSignature === afterSignature &&
+    digest === observedDigest &&
+    (!previous || previous.realpath === realpath) &&
+    (!previous || previous.signature === afterSignature);
   dependencies.set(key, {
-    digest: previous && previous.digest !== digest ? "" : digest,
+    digest: !identityStable || (previous && previous.digest !== digest) ? "" : digest,
+    identityStable,
     kind,
     owners: mergedOwners,
     path: location,
+    realpath,
+    signature: afterSignature,
   });
 }
 
+function dependencyRealpath(location) {
+  try {
+    return realPath(location);
+  } catch {
+    return null;
+  }
+}
+
 function isLocalModuleSpecifier(specifier) {
   return specifier.startsWith(".") ||
     specifier.startsWith("/") ||
@@ -2874,10 +2980,22 @@ function realPath(location) {
 }
 
 function finalizeDependencies() {
+  for (const dependency of [...dependencies.values()]) {
+    recordDependency(
+      dependency.kind,
+      dependency.path,
+      currentDependencyDigest(dependency.kind, dependency.path),
+      [...dependency.owners],
+    );
+  }
   const watched = graphWatchReachability();
-  return [...dependencies.values()].map(({ owners, ...dependency }) => ({
-    ...dependency,
-    scope: [...owners].some((owner) => watched.has(owner))
+  return [...dependencies.values()].map((dependency) => ({
+    digest: dependency.digest,
+    identityStable: dependency.identityStable,
+    kind: dependency.kind,
+    path: dependency.path,
+    realpath: dependency.realpath,
+    scope: [...dependency.owners].some((owner) => watched.has(owner))
       ? "watch"
       : "cache",
   }));
@@ -3121,9 +3239,12 @@ const resolutionRoot = path.resolve(%s);
 const CONFIG_KEYS = new Set<string>([%s]);
 const dependencies = new Map<string, {
   digest: string;
+  identityStable: boolean;
   kind: "directory" | "entry" | "file" | "optional-file";
   path: string;
   owners: Set<string>;
+  realpath: string | null;
+  signature: string | undefined;
 }>();
 const graphNodes = new Map<string, string>();
 const graphEdges: Array<{
@@ -3296,6 +3417,48 @@ function isObject(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === "object";
 }
 
+function missingPathError(error: unknown): boolean {
+  const code = (error as { code?: unknown } | undefined)?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+
+function dependencyMetadataSignature(
+  location: string,
+): string | undefined {
+  const requested = path.resolve(location);
+  let current = requested;
+  for (;;) {
+    try {
+      const link = fs.lstatSync(current, { bigint: true });
+      let target = link;
+      if (link.isSymbolicLink()) {
+        try { target = fs.statSync(current, { bigint: true }); }
+        catch { return undefined; }
+      }
+      return [path.relative(current, requested), link.dev, link.ino, link.mode, link.size, link.mtimeNs, link.ctimeNs, target.dev, target.ino, target.mode, target.size, target.mtimeNs, target.ctimeNs].join(":");
+    } catch (error) {
+      if (!missingPathError(error)) return undefined;
+      const parent = path.dirname(current);
+      if (parent === current) return undefined;
+      current = parent;
+    }
+  }
+}
+
+function currentDependencyDigest(
+  kind: "directory" | "entry" | "file" | "optional-file",
+  location: string,
+): string {
+  try {
+    if (kind === "directory") return directoryDigest(location);
+    if (kind === "entry") return entryDigest(location);
+    if (kind === "optional-file") return optionalFileDigest(location);
+    return createHash("sha256").update(fs.readFileSync(location)).digest("hex");
+  } catch {
+    return "";
+  }
+}
+
 function recordDependency(
   kind: "directory" | "entry" | "file" | "optional-file",
   location: string,
@@ -3306,14 +3469,41 @@ function recordDependency(
   const previous = dependencies.get(key);
   const mergedOwners = previous?.owners ?? new Set<string>();
   for (const owner of owners) mergedOwners.add(owner);
+  const beforeSignature = dependencyMetadataSignature(location);
+  const observedDigest = currentDependencyDigest(kind, location);
+  const realpath = dependencyRealpath(location);
+  const afterSignature = dependencyMetadataSignature(location);
+  const identityStable =
+    previous?.identityStable !== false &&
+    beforeSignature !== undefined &&
+    afterSignature !== undefined &&
+    beforeSignature === afterSignature &&
+    digest === observedDigest &&
+    (previous === undefined || previous.realpath === realpath) &&
+    (previous === undefined || previous.signature === afterSignature);
   dependencies.set(key, {
-    digest: previous !== undefined && previous.digest !== digest ? "" : digest,
+    digest:
+      !identityStable ||
+      (previous !== undefined && previous.digest !== digest)
+        ? ""
+        : digest,
+    identityStable,
     kind,
     owners: mergedOwners,
     path: location,
+    realpath,
+    signature: afterSignature,
   });
 }
 
+function dependencyRealpath(location: string): string | null {
+  try {
+    return realPath(location);
+  } catch {
+    return null;
+  }
+}
+
 function isLocalModuleSpecifier(specifier: string): boolean {
   return specifier.startsWith(".") ||
     specifier.startsWith("/") ||
@@ -4115,10 +4305,20 @@ function realPath(location: string): string {
 
 function finalizeDependencies(): Array<{
   digest: string;
+  identityStable: boolean;
   kind: "directory" | "entry" | "file" | "optional-file";
   path: string;
+  realpath: string | null;
   scope: "cache" | "watch";
 }> {
+  for (const dependency of [...dependencies.values()]) {
+    recordDependency(
+      dependency.kind,
+      dependency.path,
+      currentDependencyDigest(dependency.kind, dependency.path),
+      [...dependency.owners],
+    );
+  }
   const watched = graphWatchReachability();
   // Opt-in diagnostics for a graph that comes back empty. The only channel this
   // loader may use is stderr, because the result travels through a private file
@@ -4136,9 +4336,13 @@ function finalizeDependencies(): Array<{
         "\n",
     );
   }
-  return [...dependencies.values()].map(({ owners, ...dependency }) => ({
-    ...dependency,
-    scope: [...owners].some((owner) => watched.has(owner))
+  return [...dependencies.values()].map((dependency) => ({
+    digest: dependency.digest,
+    identityStable: dependency.identityStable,
+    kind: dependency.kind,
+    path: dependency.path,
+    realpath: dependency.realpath,
+    scope: [...dependency.owners].some((owner) => watched.has(owner))
       ? "watch"
       : "cache",
   }));
@@ -4251,6 +4455,7 @@ func typeScriptConfigLoaderTsconfig(loader, location, outDir string) string {
       // resolving either way.
       "module":                          configModuleOption(location),
       "moduleResolution":                "bundler",
+      "jsx":                             "preserve",
       "noImplicitAny":                   false,
       "outDir":                          filepath.ToSlash(filepath.Join(outDir, "out")),
       "rewriteRelativeImportExtensions": true,

package/linthost/dispatch.go

@@ -76,7 +76,7 @@ func run(args []string) int {
     // Don't pay contributor-registration cost for the version banner.
     fmt.Fprintf(os.Stdout, "@ttsc/lint %s\n", Version)
     return 0
-  case "check", "check-serve", "fix", "format", "build", "transform", "project-inputs", "lsp-command-ids", "lsp-code-action-kinds", "lsp-diagnostics", "lsp-project-diagnostics", "lsp-code-actions", "lsp-execute-command", "lsp-hints", "lsp-serve":
+  case "check", "check-serve", "fix", "format", "build", "transform", "project-inputs", "lsp-command-ids", "lsp-code-action-kinds", "lsp-diagnostics", "lsp-project-diagnostics", "lsp-code-actions", "lsp-execute-command", "lsp-hints", "graph-nodes", "lsp-serve":
   default:
     fmt.Fprintf(os.Stderr, "@ttsc/lint: unknown command %q\n", args[0])
     return 2
@@ -113,6 +113,8 @@ func run(args []string) int {
     return RunLSPExecuteCommand(args[1:])
   case "lsp-hints":
     return RunLSPHints(args[1:])
+  case "graph-nodes":
+    return RunGraphNodes(args[1:])
   case "lsp-serve":
     return RunLSPServe(os.Stdin, os.Stdout, args[1:])
   }

package/linthost/graph_nodes.go

@@ -0,0 +1,205 @@
+package linthost
+
+import (
+  "fmt"
+  "os"
+  "slices"
+
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
+)
+
+// RunGraphNodes prints the artifacts every project rule materialized for this
+// project, as JSON.
+//
+// Like the hints verb this takes no `--uri`: a set of artifacts describes the
+// Program, not a document. It loads a Program only when the resolved config
+// declares a rule that can publish one, and a caller is expected to cache the
+// answer and ask again only when the project's inputs changed.
+//
+// An empty set is a successful answer. A project with no publishing rule is the
+// common case, and a caller must be able to tell it apart from a failure; a
+// nonzero exit here would read as "the project is broken".
+func RunGraphNodes(args []string) int {
+  opts, ok := parseLSPCommandOptions("graph-nodes", args)
+  if !ok {
+    return 2
+  }
+  nodes, code := computeGraphNodes(opts)
+  if code != 0 {
+    return code
+  }
+  return writeJSON(nodes)
+}
+
+// computeGraphNodes builds the artifact set for one project. Split from
+// RunGraphNodes so a resident loop can reuse it over a warm Program, the same
+// split computeLSPHints takes.
+func computeGraphNodes(opts *lspCommandOptions) ([]publicrule.GraphNode, int) {
+  rules, err := acquireRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return nil, 2
+  }
+  engine := NewEngineWithResolver(rules)
+  if err := engine.ConfigError(); err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return nil, 2
+  }
+  publishes, needsChecker := engine.hasGraphPublisher()
+  if !publishes {
+    // Nothing the config declared can publish artifacts, so there is no
+    // projection to take and the Program is never built. This is what keeps a
+    // project that does not use the convention paying nothing for the verb.
+    return []publicrule.GraphNode{}, 0
+  }
+  prog, parseDiags, closeProgram, err := acquireProgram(opts, needsChecker)
+  if closeProgram != nil {
+    defer closeProgram()
+  }
+  if err != nil {
+    fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
+    return nil, 2
+  }
+  if prog == nil || len(parseDiags) > 0 {
+    // The project does not parse right now. Rules never ran, so there are no
+    // artifacts — but these are tsgo's diagnostics to own, and failing here
+    // would make a consumer treat a syntax error mid-typing as a broken plugin.
+    return []publicrule.GraphNode{}, 0
+  }
+  return collectProjectGraphNodes(prog.runProjectCycle(engine)), 0
+}
+
+// hasGraphPublisher reports whether any declared project rule can publish
+// artifacts, and whether serving those rules needs a type checker.
+//
+// Both answers come from the registration table and the resolved config, so
+// they are available before a Program exists — which is the point, and matters
+// more here than for hints: the artifacts a rule materializes come from parsing
+// documents, not from the type system, so a project that publishes them should
+// not pay for a checker no projection reads.
+func (e *Engine) hasGraphPublisher() (publishes bool, needsChecker bool) {
+  if e == nil {
+    return false, false
+  }
+  for _, name := range allProjectRuleNames() {
+    setting := e.projectSettings[name]
+    if !setting.Declared || setting.Severity == SeverityOff {
+      continue
+    }
+    adapter, registered := registeredProjectRules[name]
+    if !registered {
+      continue
+    }
+    if _, publisher := adapter.inner.(publicrule.GraphRule); !publisher {
+      continue
+    }
+    publishes = true
+    if projectRuleNeedsTypeChecker(name) {
+      // Every publisher's need is folded in rather than returning early: one
+      // rule declining a checker does not spare a sibling that reads one.
+      needsChecker = true
+    }
+  }
+  return publishes, needsChecker
+}
+
+// collectProjectGraphNodes gathers the artifacts every declared project rule
+// published for this Program.
+//
+// It runs after evaluateProject rather than inside it, because a set of
+// artifacts is a projection of finished state. A rule is asked only when it
+// passed and published state: a rule that failed materialized a description of
+// a Program it just rejected, and indexing that would answer questions from
+// facts the rule itself disowns.
+func collectProjectGraphNodes(cycle *projectCycle) []publicrule.GraphNode {
+  if cycle == nil || cycle.results == nil {
+    return nil
+  }
+  nodes := []publicrule.GraphNode{}
+  for _, name := range allProjectRuleNames() {
+    result, exists := cycle.results.byName[name]
+    if !exists || result.reporter == nil {
+      continue
+    }
+    adapter, registered := registeredProjectRules[name]
+    if !registered {
+      continue
+    }
+    provider, ok := adapter.inner.(publicrule.GraphRule)
+    if !ok {
+      continue
+    }
+    snapshot := result.reporter.snapshot()
+    if snapshot.Status != publicrule.ProjectRulePassed || snapshot.State == nil {
+      continue
+    }
+    nodes = append(nodes, ruleGraphNodes(name, provider, result, snapshot)...)
+  }
+  return dropUnusableGraphNodes(nodes)
+}
+
+// ruleGraphNodes calls one rule's GraphNodes behind a recover barrier.
+//
+// The barrier matches the metadata-inspection contract: a contributor panicking
+// while describing itself loses its contribution rather than the process.
+func ruleGraphNodes(
+  name string,
+  provider publicrule.GraphRule,
+  result projectCycleResult,
+  snapshot publicrule.ProjectRuleResult,
+) (nodes []publicrule.GraphNode) {
+  defer func() {
+    if recovered := recover(); recovered != nil {
+      fmt.Fprintf(
+        os.Stderr,
+        "@ttsc/lint: project rule %q panicked while publishing graph nodes: %v; dropping its artifacts\n",
+        name,
+        recovered,
+      )
+      nodes = nil
+    }
+  }()
+  return provider.GraphNodes(&publicrule.GraphContext{
+    Identity: result.identity,
+    State:    snapshot.State,
+    Severity: publicrule.Severity(result.severity),
+    Options:  result.options,
+  })
+}
+
+// dropUnusableGraphNodes removes what a consumer cannot index, and repairs the
+// one thing it can: a parent naming no published node.
+//
+// A node with no address has no identity to be cited by. A node whose kind is
+// not in the published vocabulary is one the consumer cannot rank or contain,
+// and guessing would be worse than dropping. A duplicate address is kept once,
+// first writer winning, because two nodes under one address make a citation
+// ambiguous — the rule's own aliases are how one artifact answers to two names.
+//
+// A parent that survives none of that is cleared rather than dropping its child:
+// the child is still a real artifact and still citable, it simply sits at the
+// top of its chain. Fabricating the missing parent is what must not happen.
+func dropUnusableGraphNodes(nodes []publicrule.GraphNode) []publicrule.GraphNode {
+  kinds := publicrule.GraphNodeKinds()
+  seen := make(map[string]struct{}, len(nodes))
+  kept := make([]publicrule.GraphNode, 0, len(nodes))
+  for _, node := range nodes {
+    if node.Address == "" || !slices.Contains(kinds, node.Kind) {
+      continue
+    }
+    if _, exists := seen[node.Address]; exists {
+      continue
+    }
+    seen[node.Address] = struct{}{}
+    kept = append(kept, node)
+  }
+  for index := range kept {
+    if kept[index].Parent == "" {
+      continue
+    }
+    if _, exists := seen[kept[index].Parent]; !exists {
+      kept[index].Parent = ""
+    }
+  }
+  return kept
+}

package/linthost/hints.go

@@ -36,7 +36,7 @@ func RunLSPHints(args []string) int {
 // the resident lsp-serve loop reuses it over a warm Program, the same split
 // computeLSPDiagnostics and computeLSPCodeActions already take.
 func computeLSPHints(opts *lspCommandOptions) ([]publicrule.Hint, int) {
-  rules, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  rules, err := acquireRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return nil, 2

package/linthost/project_inputs.go

@@ -30,10 +30,21 @@ func RunProjectInputs(args []string) int {
   if !ok {
     return 2
   }
-  resolver, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  snapshot, code := computeProjectInputs(opts)
+  if code != 0 {
+    return code
+  }
+  return writeJSON(snapshot)
+}
+
+// computeProjectInputs builds the dependency snapshot for one project. Split
+// from RunProjectInputs so the resident daemon can answer the same verb without
+// a process per question, the same split hints and graph-nodes take.
+func computeProjectInputs(opts *lspCommandOptions) (ProjectInputSnapshot, int) {
+  resolver, err := acquireRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
-    return 2
+    return ProjectInputSnapshot{}, 2
   }
   identity := normalizeProjectIdentity(
     opts.projectIdentity,
@@ -43,9 +54,9 @@ func RunProjectInputs(args []string) int {
   snapshot, err := collectProjectInputs(resolver, identity)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
-    return 2
+    return ProjectInputSnapshot{}, 2
   }
-  return writeJSON(snapshot)
+  return snapshot, 0
 }
 
 func collectProjectInputs(