@webpieces/nx-webpieces-rules 0.4.919 → 0.4.921

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,15 @@
  * 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_edge_diff_1 = require("./graph-edge-diff");
 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 +95,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 +113,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 +132,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,21 +149,56 @@ 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;
     defaultKind;
-    constructor(scans, defaultKind) {
+    edges;
+    constructor(scans, defaultKind, 
+    /**
+     * The edges this branch gained or lost since its FORK POINT, the live graph against the fork
+     * point's committed one (graph-edge-diff.ts, #1264). One per sidecar: it does not depend on
+     * which scan is shown.
+     */
+    edges) {
         this.scans = scans;
         this.defaultKind = defaultKind;
+        this.edges = edges;
     }
 }
 exports.ImpactSidecarData = ImpactSidecarData;
@@ -311,28 +356,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.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.ProjectFileOwners = ProjectFileOwners;
+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 +407,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 +453,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 +485,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 +508,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 +524,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));
@@ -519,16 +573,19 @@ class ImpactRefresh {
     scanner;
     sidecar;
     resolver;
-    constructor(scanner = new NxImpactScanner(), sidecar = new ImpactSidecar(), resolver = new ImpactScopeResolver()) {
+    edges;
+    constructor(scanner = new NxImpactScanner(), sidecar = new ImpactSidecar(), resolver = new ImpactScopeResolver(), edges = new graph_edge_diff_1.EdgeChangeScanner()) {
         this.scanner = scanner;
         this.sidecar = sidecar;
         this.resolver = resolver;
+        this.edges = edges;
     }
     /**
      * Scans the comparisons in `kinds` that exist here (`VISUALIZE_IMPACT_KINDS` /
-     * `GENERATE_IMPACT_KINDS`). Never throws — Impact is optional, generation is not.
+     * `GENERATE_IMPACT_KINDS`), and the edge changes since the fork point against the LIVE graphs
+     * `live` computes. Never throws — Impact is optional, generation is not.
      */
-    async run(architectureDir, workspaceRoot, graph, kinds) {
+    async run(architectureDir, workspaceRoot, graph, kinds, live) {
         const started = Date.now();
         // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- impact is optional; any failure becomes a reason, never a failed generation
         try {
@@ -546,8 +603,12 @@ class ImpactRefresh {
                 this.sidecar.remove(architectureDir);
                 return [...lines, `ℹ️  Impact disabled, no sidecar written (${cost})`].join('\n');
             }
-            const file = this.sidecar.write(architectureDir, new ImpactSidecarData(scans, this.defaultKind(scans, plan.defaultKind)));
-            return [...lines, file === null ? `⚠️  Impact sidecar not written (${cost})` : `→ ${file} (${cost})`].join('\n');
+            const fork = plan.comparisons.find((comparison) => comparison.kind === ImpactKind.BRANCH);
+            const edges = await this.edges.scan(workspaceRoot, fork?.base ?? null, live);
+            lines.push(this.edgeLine(edges));
+            const data = new ImpactSidecarData(scans, this.defaultKind(scans, plan.defaultKind), edges);
+            const file = this.sidecar.write(architectureDir, data);
+            return [...lines, file === null ? `⚠️  Impact sidecar not written (${Date.now() - started} ms)` : `→ ${file} (${Date.now() - started} ms)`].join('\n');
         }
         catch (err) {
             const error = (0, toError_1.toError)(err);
@@ -555,6 +616,17 @@ class ImpactRefresh {
             return `⚠️  Impact skipped: ${error.message}`;
         }
     }
+    /** `✅ Edges since abc1234: dependencies 1 gained · 1 lost; runtime 0 gained · 0 lost`, or why not. */
+    edgeLine(edges) {
+        const half = (name, reason, changes) => {
+            if (reason !== '')
+                return `${name}: ${reason}`;
+            const gained = changes.filter((change) => change.change === graph_edge_diff_1.EdgeChangeKind.GAINED).length;
+            return `${name} ${gained} gained · ${changes.length - gained} lost`;
+        };
+        const head = edges.base === '' ? 'ℹ️  Edges' : `✅ Edges since ${edges.base}`;
+        return `${head}: ${half('dependencies', edges.dependencyReason, edges.dependency)}; ${half('runtime', edges.runtimeReason, edges.runtime)}`;
+    }
     /** The plan's default when that scan is available, else the first available one. */
     defaultKind(scans, preferred) {
         const usable = scans.filter((scan) => scan.available);
@@ -571,8 +643,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;