@webpieces/nx-webpieces-rules 0.4.918 → 0.4.920

package/src/lib/graph-impact.d.ts

@@ -1,5 +1,5 @@
 /**
- * Impact mode's data: what one COMPARISON's build looks like, in three shades (plus untouched grey).
+ * Impact mode's data: what one COMPARISON's build looks like, and WHY each project is in it.
  *
  * There are two comparisons, and only two (#1163). Both end at the WORKING TREE, so uncommitted and
  * untracked work counts in either:
@@ -25,15 +25,13 @@
  *  - AFFECTED is `nx show projects --affected --base=<the comparison's base> --json`, with NO
  *    `--head`, so uncommitted and untracked work counts. nx already gets right everything a
  *    hand-rolled diff gets wrong: lockfile and package.json changes resolved per project, root/global
- *    inputs, namedInputs, implicitDependencies, nested roots and deleted files. This uses its public
- *    CLI surface only, never nx internals, and never NX_BASE/NX_HEAD, whose value depends on whoever
- *    launched the process.
- *  - TOUCHED is the subset of that set which OWNS a changed file, by nx's own file-to-project
- *    ownership (the project file map from `createProjectFileMapUsingProjectGraph`, public devkit API)
- *    — never a path-prefix guess. The ownership map is computed ONCE and shared by every comparison.
- *    A project whose only change is a DELETED file is not in that map (the file is gone), so it shows
- *    as affected rather than touched. The changed-file list is `DiffScope.getChangedFiles`, the same
- *    base→working-tree diff (with untracked files) every code rule uses.
+ *    inputs, namedInputs, implicitDependencies, nested roots and deleted files. It never reads
+ *    NX_BASE/NX_HEAD, whose value depends on whoever launched the process.
+ *  - WHY each affected project is in it (#1264) — changed, dependent (with the edge path), implicitly
+ *    touched (with the target, glob and file) or root-file touched — comes from nx's OWN affected
+ *    locators, run in-process against the workspace's own nx (graph-impact-reasons.ts). They are
+ *    loaded ONCE and shared by every comparison. The changed-file list is `DiffScope.getChangedFiles`,
+ *    the same base→working-tree diff (with untracked files) every code rule uses.
  *
  * The answer changes per checkout, so it never goes into the committed dependencies.html or
  * dependencies.json (both stay byte-stable). It goes into a SIDECAR,
@@ -52,7 +50,11 @@
  * stale one is removed) and the page disables Impact with a one-line reason. It never fails
  * generation.
  */
+import type { NxJsonConfiguration, ProjectGraph } from '@nx/devkit';
+import type { FileChange } from 'nx/src/project-graph/file-utils';
+import type { PackageJson } from 'nx/src/utils/package-json';
 import { DiffScope } from '@webpieces/rules-config';
+import { AffectedClassification, AffectedClassifier, AffectedReason, WorkspaceNx } from './graph-impact-reasons';
 import type { EnhancedGraph } from './graph-sorter';
 /** Relative to the architecture/ directory the page lives in; the page's `<script src>`. */
 export declare const IMPACT_SIDECAR_DIR = ".impact";
@@ -84,10 +86,16 @@ export declare class ImpactReport {
     readonly reason: string;
     /** The base's short sha ('' when there is none). */
     readonly base: string;
-    /** Affected AND owning a changed file (node ids). */
+    /** Affected AND owning a changed file (node ids): "changed". */
     readonly touched: string[];
-    /** Affected but owning no changed file (node ids): their ci re-runs. */
-    readonly affected: string[];
+    /** Affected through dependency edges from a changed or touched project (node ids). */
+    readonly dependents: string[];
+    /** Affected because a `{workspaceRoot}` target input matched a changed file (node ids). */
+    readonly implicit: string[];
+    /** Affected by a lockfile, package.json, tsconfig.base.json, nx.json or deleted-config change (node ids). */
+    readonly rootFile: string[];
+    /** Affected, and nothing here could say why (node ids). Never shown as a dependent. */
+    readonly unexplained: string[];
     /**
      * Transitive dependencies of the affected set that are NOT affected (node ids). `ci` dependsOn
      * `^build`, so they must exist as build output although their inputs did not change: nx
@@ -98,16 +106,16 @@ export declare class ImpactReport {
     readonly changedFiles: number;
     /**
      * Transitive dependencies of the TOUCHED set that are not touched themselves (node ids): the
-     * Filter popover's "Changed + dependencies". ("Changed + dependents" is touched + affected,
-     * which nx already computed as the dependents whose tests re-run.)
+     * Filter popover's "Changed + dependencies". ("Changed + dependents" is every affected project.)
      */
     readonly dependencies: string[];
     /**
      * Changed files no project owns (repo-relative, sorted): workspace-global inputs such as
-     * pnpm-lock.yaml. When nothing is touched they are WHY everything is affected, and the
-     * legend names them. Empty when nx's file ownership was unavailable — then nothing is known.
+     * pnpm-lock.yaml. Empty when nx's locators were unavailable — then nothing is known.
      */
     readonly globalFiles: string[];
+    /** WHY each affected project is in the build (graph-impact-reasons.ts): one per affected node. */
+    readonly reasons: AffectedReason[];
     constructor(kind: ImpactKind, 
     /** What the page says this scan compares, e.g. "Changed on this branch (since abc1234)". */
     label: string, 
@@ -117,10 +125,16 @@ export declare class ImpactReport {
     reason: string, 
     /** The base's short sha ('' when there is none). */
     base: string, 
-    /** Affected AND owning a changed file (node ids). */
+    /** Affected AND owning a changed file (node ids): "changed". */
     touched: string[], 
-    /** Affected but owning no changed file (node ids): their ci re-runs. */
-    affected: string[], 
+    /** Affected through dependency edges from a changed or touched project (node ids). */
+    dependents: string[], 
+    /** Affected because a `{workspaceRoot}` target input matched a changed file (node ids). */
+    implicit: string[], 
+    /** Affected by a lockfile, package.json, tsconfig.base.json, nx.json or deleted-config change (node ids). */
+    rootFile: string[], 
+    /** Affected, and nothing here could say why (node ids). Never shown as a dependent. */
+    unexplained: string[], 
     /**
      * Transitive dependencies of the affected set that are NOT affected (node ids). `ci` dependsOn
      * `^build`, so they must exist as build output although their inputs did not change: nx
@@ -130,16 +144,22 @@ export declare class ImpactReport {
     buildInputs: string[], changedFiles: number, 
     /**
      * Transitive dependencies of the TOUCHED set that are not touched themselves (node ids): the
-     * Filter popover's "Changed + dependencies". ("Changed + dependents" is touched + affected,
-     * which nx already computed as the dependents whose tests re-run.)
+     * Filter popover's "Changed + dependencies". ("Changed + dependents" is every affected project.)
      */
     dependencies: string[], 
     /**
      * Changed files no project owns (repo-relative, sorted): workspace-global inputs such as
-     * pnpm-lock.yaml. When nothing is touched they are WHY everything is affected, and the
-     * legend names them. Empty when nx's file ownership was unavailable — then nothing is known.
+     * pnpm-lock.yaml. Empty when nx's locators were unavailable — then nothing is known.
      */
-    globalFiles: string[]);
+    globalFiles: string[], 
+    /** WHY each affected project is in the build (graph-impact-reasons.ts): one per affected node. */
+    reasons: AffectedReason[]);
+}
+/** The one-line count split, shared by the executor's console line (the page builds the same line). */
+export declare class ImpactCounts {
+    /** `8 changed · 3 dependents · 22 implicitly touched (runtime-wiring-check inputs) · 47 dependencies`. */
+    line(report: ImpactReport): string;
+    private targets;
 }
 /** The sidecar's one global: every scan, and the one the page shows first. */
 export declare class ImpactSidecarData {
@@ -210,49 +230,64 @@ export declare class NxCli {
     /** Resolved the way node would from the workspace, so a linked worktree finds its main tree's nx. */
     private binary;
 }
-/** nx's own file → project ownership, from the public devkit file map. Injected for specs. */
-export declare class ProjectFileOwners {
-    owners(): Promise<Map<string, string>>;
+/**
+ * The workspace's nx facts every comparison classifies against: its project graph (with npm nodes
+ * and every edge), nx.json, package.json, and nx's own affected locators. Subclassed by specs.
+ */
+export declare class AffectedContext {
+    readonly graph: ProjectGraph;
+    readonly nxJson: NxJsonConfiguration;
+    readonly packageJson: PackageJson;
+    readonly classifier: AffectedClassifier;
+    private readonly nx;
+    constructor(graph: ProjectGraph, nxJson: NxJsonConfiguration, packageJson: PackageJson, classifier: AffectedClassifier, nx: WorkspaceNx | null);
+    /** nx's FileChange list for `files`, base → working tree. */
+    fileChanges(files: string[], base: string): FileChange[];
+}
+/** Loads the workspace's nx facts. Injected so specs never load the real project graph. */
+export declare class AffectedContextLoader {
+    load(workspaceRoot: string): Promise<AffectedContext>;
 }
 /**
- * nx's ownership map, computed at most ONCE however many comparisons ask for it. Failing is not
- * fatal: the set then shows in one shade, all "affected".
+ * The context, loaded at most ONCE however many comparisons ask for it. Failing is not fatal: every
+ * affected project is then "unexplained", with this error as its reason — never a dependent.
  */
-export declare class SharedOwners {
-    private readonly ownership;
+export declare class SharedContext {
+    private readonly loader;
+    private readonly workspaceRoot;
     private pending;
-    constructor(ownership: ProjectFileOwners);
-    get(): Promise<Map<string, string>>;
+    constructor(loader: AffectedContextLoader, workspaceRoot: string);
+    get(): Promise<AffectedContext | Error>;
     private load;
 }
 export declare class NxImpactScanner {
     private readonly diffScope;
     private readonly nx;
-    private readonly ownership;
+    private readonly loader;
     private readonly names;
-    constructor(diffScope?: DiffScope, nx?: NxCli, ownership?: ProjectFileOwners);
-    /** Every comparison, in order, sharing one ownership map. */
+    constructor(diffScope?: DiffScope, nx?: NxCli, loader?: AffectedContextLoader);
+    /** Every comparison, in order, sharing one nx context. */
     scanAll(workspaceRoot: string, graph: EnhancedGraph, comparisons: ImpactComparison[]): Promise<(ImpactReport | ImpactUnavailable)[]>;
     /** One comparison: nx affected from ITS base, with NO `--head`, so uncommitted work counts. */
-    scan(workspaceRoot: string, graph: EnhancedGraph, comparison: ImpactComparison, owners?: SharedOwners): Promise<ImpactReport | ImpactUnavailable>;
+    scan(workspaceRoot: string, graph: EnhancedGraph, comparison: ImpactComparison, context?: SharedContext): Promise<ImpactReport | ImpactUnavailable>;
+    /** nx's locators' answer; any failure makes every affected project "unexplained", with the reason. */
+    classify(context: AffectedContext | Error, files: string[], base: string, affected: string[]): Promise<AffectedClassification>;
     /**
      * An empty scan is still an ANSWER (available, zero sets): a fresh branch with a clean tree has
      * simply changed nothing yet, and the page says so instead of disabling Impact.
      */
     emptyNote(comparison: ImpactComparison, changedFiles: number, short: string): string;
-    /** Changed files no project owns; none are claimed when ownership itself was unavailable. */
-    globalFiles(files: string[], owners: Map<string, string>): string[];
     /**
      * Every transitive dependency of `roots` that is not itself one of them: a pure downward walk over
      * the graph's own dependsOn edges, no nx call. Of the affected set these are the build inputs; of
      * the touched set, "Changed + dependencies".
      */
     buildInputs(roots: string[], graph: EnhancedGraph): string[];
-    /** Affected projects that own one of the changed files, by nx's own ownership. */
-    touched(affected: string[], files: string[], owners: Map<string, string>): string[];
-    /** The JSON list, narrowed to projects the graph draws; null when it is not a list of names. */
-    parse(json: string, graph: EnhancedGraph): string[] | null;
+    /** The JSON list of project names, sorted; null when it is not a list of names. */
+    parse(json: string): string[] | null;
+    /** The drawn projects only: a reason for a project the page does not draw has nowhere to show. */
     private report;
+    private empty;
     private ids;
 }
 /** Writes (or removes) the sidecar, self-ignored, beside architecture/dependencies.html. */

package/src/lib/graph-impact.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Impact mode's data: what one COMPARISON's build looks like, in three shades (plus untouched grey).
+ * Impact mode's data: what one COMPARISON's build looks like, and WHY each project is in it.
  *
  * There are two comparisons, and only two (#1163). Both end at the WORKING TREE, so uncommitted and
  * untracked work counts in either:
@@ -26,15 +26,13 @@
  *  - AFFECTED is `nx show projects --affected --base=<the comparison's base> --json`, with NO
  *    `--head`, so uncommitted and untracked work counts. nx already gets right everything a
  *    hand-rolled diff gets wrong: lockfile and package.json changes resolved per project, root/global
- *    inputs, namedInputs, implicitDependencies, nested roots and deleted files. This uses its public
- *    CLI surface only, never nx internals, and never NX_BASE/NX_HEAD, whose value depends on whoever
- *    launched the process.
- *  - TOUCHED is the subset of that set which OWNS a changed file, by nx's own file-to-project
- *    ownership (the project file map from `createProjectFileMapUsingProjectGraph`, public devkit API)
- *    — never a path-prefix guess. The ownership map is computed ONCE and shared by every comparison.
- *    A project whose only change is a DELETED file is not in that map (the file is gone), so it shows
- *    as affected rather than touched. The changed-file list is `DiffScope.getChangedFiles`, the same
- *    base→working-tree diff (with untracked files) every code rule uses.
+ *    inputs, namedInputs, implicitDependencies, nested roots and deleted files. It never reads
+ *    NX_BASE/NX_HEAD, whose value depends on whoever launched the process.
+ *  - WHY each affected project is in it (#1264) — changed, dependent (with the edge path), implicitly
+ *    touched (with the target, glob and file) or root-file touched — comes from nx's OWN affected
+ *    locators, run in-process against the workspace's own nx (graph-impact-reasons.ts). They are
+ *    loaded ONCE and shared by every comparison. The changed-file list is `DiffScope.getChangedFiles`,
+ *    the same base→working-tree diff (with untracked files) every code rule uses.
  *
  * The answer changes per checkout, so it never goes into the committed dependencies.html or
  * dependencies.json (both stay byte-stable). It goes into a SIDECAR,
@@ -54,13 +52,14 @@
  * generation.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImpactRefresh = exports.ImpactSidecar = exports.NxImpactScanner = exports.SharedOwners = exports.ProjectFileOwners = exports.NxCli = exports.ImpactScopeResolver = exports.ImpactGit = exports.ImpactPlan = exports.ImpactComparison = exports.ImpactUnavailable = exports.ImpactSidecarData = exports.ImpactReport = exports.GENERATE_IMPACT_KINDS = exports.VISUALIZE_IMPACT_KINDS = exports.ImpactKind = exports.UNCOMMITTED_SUFFIX = exports.ROOT_COMMIT_REASON = exports.NOTHING_CHANGED_ON_BRANCH = exports.IMPACT_SIDECAR_SRC = exports.IMPACT_SIDECAR_FILE = exports.IMPACT_SIDECAR_DIR = void 0;
+exports.ImpactRefresh = exports.ImpactSidecar = exports.NxImpactScanner = exports.SharedContext = exports.AffectedContextLoader = exports.AffectedContext = exports.NxCli = exports.ImpactScopeResolver = exports.ImpactGit = exports.ImpactPlan = exports.ImpactComparison = exports.ImpactUnavailable = exports.ImpactSidecarData = exports.ImpactCounts = exports.ImpactReport = exports.GENERATE_IMPACT_KINDS = exports.VISUALIZE_IMPACT_KINDS = exports.ImpactKind = exports.UNCOMMITTED_SUFFIX = exports.ROOT_COMMIT_REASON = exports.NOTHING_CHANGED_ON_BRANCH = exports.IMPACT_SIDECAR_SRC = exports.IMPACT_SIDECAR_FILE = exports.IMPACT_SIDECAR_DIR = void 0;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
 const devkit_1 = require("@nx/devkit");
 const rules_config_1 = require("@webpieces/rules-config");
+const graph_impact_reasons_1 = require("./graph-impact-reasons");
 const graph_names_1 = require("./graph-names");
 const toError_1 = require("../toError");
 /** Relative to the architecture/ directory the page lives in; the page's `<script src>`. */
@@ -95,11 +94,15 @@ class ImpactReport {
     reason;
     base;
     touched;
-    affected;
+    dependents;
+    implicit;
+    rootFile;
+    unexplained;
     buildInputs;
     changedFiles;
     dependencies;
     globalFiles;
+    reasons;
     constructor(kind, 
     /** What the page says this scan compares, e.g. "Changed on this branch (since abc1234)". */
     label, 
@@ -109,10 +112,16 @@ class ImpactReport {
     reason, 
     /** The base's short sha ('' when there is none). */
     base, 
-    /** Affected AND owning a changed file (node ids). */
+    /** Affected AND owning a changed file (node ids): "changed". */
     touched, 
-    /** Affected but owning no changed file (node ids): their ci re-runs. */
-    affected, 
+    /** Affected through dependency edges from a changed or touched project (node ids). */
+    dependents, 
+    /** Affected because a `{workspaceRoot}` target input matched a changed file (node ids). */
+    implicit, 
+    /** Affected by a lockfile, package.json, tsconfig.base.json, nx.json or deleted-config change (node ids). */
+    rootFile, 
+    /** Affected, and nothing here could say why (node ids). Never shown as a dependent. */
+    unexplained, 
     /**
      * Transitive dependencies of the affected set that are NOT affected (node ids). `ci` dependsOn
      * `^build`, so they must exist as build output although their inputs did not change: nx
@@ -122,16 +131,16 @@ class ImpactReport {
     buildInputs, changedFiles, 
     /**
      * Transitive dependencies of the TOUCHED set that are not touched themselves (node ids): the
-     * Filter popover's "Changed + dependencies". ("Changed + dependents" is touched + affected,
-     * which nx already computed as the dependents whose tests re-run.)
+     * Filter popover's "Changed + dependencies". ("Changed + dependents" is every affected project.)
      */
     dependencies, 
     /**
      * Changed files no project owns (repo-relative, sorted): workspace-global inputs such as
-     * pnpm-lock.yaml. When nothing is touched they are WHY everything is affected, and the
-     * legend names them. Empty when nx's file ownership was unavailable — then nothing is known.
+     * pnpm-lock.yaml. Empty when nx's locators were unavailable — then nothing is known.
      */
-    globalFiles) {
+    globalFiles, 
+    /** WHY each affected project is in the build (graph-impact-reasons.ts): one per affected node. */
+    reasons) {
         this.kind = kind;
         this.label = label;
         this.dirty = dirty;
@@ -139,14 +148,41 @@ class ImpactReport {
         this.reason = reason;
         this.base = base;
         this.touched = touched;
-        this.affected = affected;
+        this.dependents = dependents;
+        this.implicit = implicit;
+        this.rootFile = rootFile;
+        this.unexplained = unexplained;
         this.buildInputs = buildInputs;
         this.changedFiles = changedFiles;
         this.dependencies = dependencies;
         this.globalFiles = globalFiles;
+        this.reasons = reasons;
     }
 }
 exports.ImpactReport = ImpactReport;
+/** The one-line count split, shared by the executor's console line (the page builds the same line). */
+class ImpactCounts {
+    /** `8 changed · 3 dependents · 22 implicitly touched (runtime-wiring-check inputs) · 47 dependencies`. */
+    line(report) {
+        const parts = [`${report.touched.length} changed`, `${report.dependents.length} dependents`];
+        if (report.implicit.length > 0)
+            parts.push(`${report.implicit.length} implicitly touched${this.targets(report)}`);
+        if (report.rootFile.length > 0)
+            parts.push(`${report.rootFile.length} root-file touched`);
+        if (report.unexplained.length > 0)
+            parts.push(`${report.unexplained.length} unexplained`);
+        parts.push(`${report.buildInputs.length} dependencies`);
+        return parts.join(' · ');
+    }
+    targets(report) {
+        const targets = new Set();
+        for (const reason of report.reasons)
+            if (reason.kind === graph_impact_reasons_1.AffectedClass.IMPLICIT && reason.target !== '')
+                targets.add(reason.target);
+        return targets.size === 0 ? '' : ` (${[...targets].sort().join(', ')} inputs)`;
+    }
+}
+exports.ImpactCounts = ImpactCounts;
 /** The sidecar's one global: every scan, and the one the page shows first. */
 class ImpactSidecarData {
     scans;
@@ -311,28 +347,50 @@ class NxCli {
     }
 }
 exports.NxCli = NxCli;
-/** nx's own file → project ownership, from the public devkit file map. Injected for specs. */
-class ProjectFileOwners {
-    async owners() {
-        const fileMap = await (0, devkit_1.createProjectFileMapUsingProjectGraph)(await (0, devkit_1.createProjectGraphAsync)());
-        const owners = new Map();
-        for (const project of Object.keys(fileMap)) {
-            for (const data of fileMap[project])
-                owners.set(data.file, project);
-        }
-        return owners;
+/**
+ * The workspace's nx facts every comparison classifies against: its project graph (with npm nodes
+ * and every edge), nx.json, package.json, and nx's own affected locators. Subclassed by specs.
+ */
+class AffectedContext {
+    graph;
+    nxJson;
+    packageJson;
+    classifier;
+    nx;
+    constructor(graph, nxJson, packageJson, classifier, nx) {
+        this.graph = graph;
+        this.nxJson = nxJson;
+        this.packageJson = packageJson;
+        this.classifier = classifier;
+        this.nx = nx;
+    }
+    /** nx's FileChange list for `files`, base → working tree. */
+    fileChanges(files, base) {
+        if (this.nx === null)
+            throw new Error('no workspace nx to read file changes with');
+        return this.nx.fileChanges(files, base);
     }
 }
-exports.ProjectFileOwners = ProjectFileOwners;
+exports.AffectedContext = AffectedContext;
+/** Loads the workspace's nx facts. Injected so specs never load the real project graph. */
+class AffectedContextLoader {
+    async load(workspaceRoot) {
+        const nx = new graph_impact_reasons_1.WorkspaceNx(workspaceRoot);
+        return new AffectedContext(await (0, devkit_1.createProjectGraphAsync)(), nx.nxJson(), nx.packageJson(), new graph_impact_reasons_1.AffectedClassifier(nx.locators()), nx);
+    }
+}
+exports.AffectedContextLoader = AffectedContextLoader;
 /**
- * nx's ownership map, computed at most ONCE however many comparisons ask for it. Failing is not
- * fatal: the set then shows in one shade, all "affected".
+ * The context, loaded at most ONCE however many comparisons ask for it. Failing is not fatal: every
+ * affected project is then "unexplained", with this error as its reason — never a dependent.
  */
-class SharedOwners {
-    ownership;
+class SharedContext {
+    loader;
+    workspaceRoot;
     pending = null;
-    constructor(ownership) {
-        this.ownership = ownership;
+    constructor(loader, workspaceRoot) {
+        this.loader = loader;
+        this.workspaceRoot = workspaceRoot;
     }
     get() {
         if (this.pending === null)
@@ -340,60 +398,45 @@ class SharedOwners {
         return this.pending;
     }
     async load() {
-        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- the second shade is optional
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- the reasons are optional; the affected set still shows
         try {
-            return await this.ownership.owners();
+            return await this.loader.load(this.workspaceRoot);
         }
         catch (err) {
             const error = (0, toError_1.toError)(err);
-            console.warn(`⚠️  Impact: nx file ownership unavailable (${error.message}); showing one shade`);
-            return new Map();
+            console.warn(`⚠️  Impact: nx's affected locators unavailable (${error.message}); reasons unknown`);
+            return error;
         }
     }
 }
-exports.SharedOwners = SharedOwners;
-/** The sets one scan found; an empty one is still an answer. */
-class ImpactSets {
-    touched;
-    affected;
-    buildInputs;
-    dependencies;
-    globalFiles;
-    constructor(touched = [], affected = [], buildInputs = [], dependencies = [], globalFiles = []) {
-        this.touched = touched;
-        this.affected = affected;
-        this.buildInputs = buildInputs;
-        this.dependencies = dependencies;
-        this.globalFiles = globalFiles;
-    }
-}
+exports.SharedContext = SharedContext;
 class NxImpactScanner {
     diffScope;
     nx;
-    ownership;
+    loader;
     names = new graph_names_1.GraphNames();
-    constructor(diffScope = new rules_config_1.DiffScope(), nx = new NxCli(), ownership = new ProjectFileOwners()) {
+    constructor(diffScope = new rules_config_1.DiffScope(), nx = new NxCli(), loader = new AffectedContextLoader()) {
         this.diffScope = diffScope;
         this.nx = nx;
-        this.ownership = ownership;
+        this.loader = loader;
     }
-    /** Every comparison, in order, sharing one ownership map. */
+    /** Every comparison, in order, sharing one nx context. */
     async scanAll(workspaceRoot, graph, comparisons) {
-        const owners = new SharedOwners(this.ownership);
+        const context = new SharedContext(this.loader, workspaceRoot);
         const results = [];
         for (const comparison of comparisons)
-            results.push(await this.scan(workspaceRoot, graph, comparison, owners));
+            results.push(await this.scan(workspaceRoot, graph, comparison, context));
         return results;
     }
     /** One comparison: nx affected from ITS base, with NO `--head`, so uncommitted work counts. */
-    async scan(workspaceRoot, graph, comparison, owners = new SharedOwners(this.ownership)) {
+    async scan(workspaceRoot, graph, comparison, context = new SharedContext(this.loader, workspaceRoot)) {
         const base = comparison.base;
         if (base === null)
-            return this.report(comparison, false, comparison.reason, '', 0, new ImpactSets());
+            return this.empty(comparison, false, comparison.reason, '', 0);
         const json = this.nx.run(workspaceRoot, ['show', 'projects', '--affected', `--base=${base}`, '--json'], NX_TIMEOUT_MS);
         if (json === null)
             return new ImpactUnavailable(`nx show projects --affected failed or took over ${NX_TIMEOUT_MS / 1000}s`, comparison.label);
-        const affectedSet = this.parse(json, graph);
+        const affectedSet = this.parse(json);
         if (affectedSet === null)
             return new ImpactUnavailable('nx show projects --affected printed something other than a JSON list', comparison.label);
         const options = new rules_config_1.ChangedFilesOptions();
@@ -401,13 +444,26 @@ class NxImpactScanner {
         options.includeDeletions = true;
         const files = this.diffScope.getChangedFiles(workspaceRoot, base, undefined, options);
         const short = base.slice(0, 7);
-        if (affectedSet.length === 0)
-            return this.report(comparison, true, this.emptyNote(comparison, files.length, short), short, files.length, new ImpactSets());
-        const map = await owners.get();
-        const touched = this.touched(affectedSet, files, map);
-        const rest = affectedSet.filter((project) => !touched.includes(project));
-        const sets = new ImpactSets(this.ids(touched), this.ids(rest), this.ids(this.buildInputs(affectedSet, graph)), this.ids(this.buildInputs(touched, graph)), this.globalFiles(files, map));
-        return this.report(comparison, true, '', short, files.length, sets);
+        const drawn = affectedSet.filter((project) => graph[project] !== undefined);
+        if (drawn.length === 0)
+            return this.empty(comparison, true, this.emptyNote(comparison, files.length, short), short, files.length);
+        const classification = await this.classify(await context.get(), files, base, affectedSet);
+        return this.report(comparison, short, files.length, graph, classification);
+    }
+    /** nx's locators' answer; any failure makes every affected project "unexplained", with the reason. */
+    async classify(context, files, base, affected) {
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- the reasons are optional; a locator failure leaves them unknown
+        try {
+            if (context instanceof Error)
+                throw context;
+            const changes = context.fileChanges(files, base);
+            return await context.classifier.classify(new graph_impact_reasons_1.AffectedInputs(context.graph, context.nxJson, context.packageJson, changes, affected));
+        }
+        catch (err) {
+            const error = (0, toError_1.toError)(err);
+            const why = `nx's affected locators could not run here (${error.message}), so why nx marked it is unknown`;
+            return new graph_impact_reasons_1.AffectedClassification([...affected].sort().map((project) => new graph_impact_reasons_1.AffectedReason(project, graph_impact_reasons_1.AffectedClass.UNEXPLAINED, [], [], '', '', why)), []);
+        }
     }
     /**
      * An empty scan is still an ANSWER (available, zero sets): a fresh branch with a clean tree has
@@ -420,12 +476,6 @@ class NxImpactScanner {
             return `Nothing changed since ${short}`;
         return `Nothing affected since ${short}`;
     }
-    /** Changed files no project owns; none are claimed when ownership itself was unavailable. */
-    globalFiles(files, owners) {
-        if (owners.size === 0)
-            return [];
-        return files.filter((file) => !owners.has(file)).sort();
-    }
     /**
      * Every transitive dependency of `roots` that is not itself one of them: a pure downward walk over
      * the graph's own dependsOn edges, no nx call. Of the affected set these are the build inputs; of
@@ -449,27 +499,15 @@ class NxImpactScanner {
         }
         return inputs.sort();
     }
-    /** Affected projects that own one of the changed files, by nx's own ownership. */
-    touched(affected, files, owners) {
-        const owning = new Set();
-        for (const file of files) {
-            const owner = owners.get(file);
-            if (owner !== undefined)
-                owning.add(owner);
-        }
-        return affected.filter((project) => owning.has(project));
-    }
-    /** The JSON list, narrowed to projects the graph draws; null when it is not a list of names. */
-    parse(json, graph) {
+    /** The JSON list of project names, sorted; null when it is not a list of names. */
+    parse(json) {
         // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- untrusted CLI output; anything unparseable is reported as a reason
         try {
             // webpieces-disable no-any-unknown -- CLI JSON is untrusted until narrowed below
             const parsed = JSON.parse(json);
             if (!Array.isArray(parsed))
                 return null;
-            return parsed
-                .filter((name) => typeof name === 'string' && graph[name] !== undefined)
-                .sort();
+            return parsed.filter((name) => typeof name === 'string').sort();
         }
         catch (err) {
             const error = (0, toError_1.toError)(err);
@@ -477,8 +515,15 @@ class NxImpactScanner {
             return null;
         }
     }
-    report(comparison, available, reason, base, changedFiles, sets) {
-        return new ImpactReport(comparison.kind, comparison.label, comparison.dirty, available, reason, base, sets.touched, sets.affected, sets.buildInputs, changedFiles, sets.dependencies, sets.globalFiles);
+    /** The drawn projects only: a reason for a project the page does not draw has nowhere to show. */
+    report(comparison, short, changedFiles, graph, classification) {
+        const drawn = (projects) => projects.filter((project) => graph[project] !== undefined);
+        const touched = drawn(classification.of(graph_impact_reasons_1.AffectedClass.CHANGED));
+        const affected = drawn(classification.reasons.map((reason) => reason.project));
+        return new ImpactReport(comparison.kind, comparison.label, comparison.dirty, true, '', short, this.ids(touched), this.ids(drawn(classification.of(graph_impact_reasons_1.AffectedClass.DEPENDENT))), this.ids(drawn(classification.of(graph_impact_reasons_1.AffectedClass.IMPLICIT))), this.ids(drawn(classification.of(graph_impact_reasons_1.AffectedClass.ROOT_FILE))), this.ids(drawn(classification.of(graph_impact_reasons_1.AffectedClass.UNEXPLAINED))), this.ids(this.buildInputs(affected, graph)), changedFiles, this.ids(this.buildInputs(touched, graph)), classification.globalFiles, classification.reasons.filter((reason) => graph[reason.project] !== undefined));
+    }
+    empty(comparison, available, reason, base, changedFiles) {
+        return new ImpactReport(comparison.kind, comparison.label, comparison.dirty, available, reason, base, [], [], [], [], [], [], changedFiles, [], [], []);
     }
     ids(projects) {
         return projects.map((project) => this.names.getNodeId(project));
@@ -571,8 +616,7 @@ class ImpactRefresh {
             return `ℹ️  Impact · ${result.label}: unavailable — ${result.reason}`;
         if (result.reason !== '')
             return `✅ Impact · ${result.label}: ${result.reason}`;
-        return (`✅ Impact · ${result.label}: ${result.touched.length} changed · ${result.affected.length} dependents · ` +
-            `${result.buildInputs.length} dependencies, from ${result.changedFiles} changed file(s)`);
+        return `✅ Impact · ${result.label}: ${new ImpactCounts().line(result)}, from ${result.changedFiles} changed file(s)`;
     }
 }
 exports.ImpactRefresh = ImpactRefresh;