@webpieces/nx-webpieces-rules 0.4.874 → 0.4.876

package/src/lib/graph-impact.js

@@ -1,44 +1,60 @@
 "use strict";
 /**
- * Impact mode's data: what THIS BRANCH's build looks like, in three shades (plus untouched grey).
+ * Impact mode's data: what one COMPARISON's build looks like, in three shades (plus untouched grey).
  *
+ * There are two comparisons, and only two (#1163). Both end at the WORKING TREE, so uncommitted and
+ * untracked work counts in either:
+ *
+ *  - BRANCH, "Changed on this branch": the fork point (`DiffScope.detectBase` in rules-config:
+ *    `git merge-base HEAD origin/main`, falling back to `main`) → working tree.
+ *  - COMMIT, "Last commit": `HEAD^` → working tree. To see what another commit changed, check it out
+ *    (`git checkout <hash>`) and run `pnpm arch:visualize`: nx computes `--affected` against the code
+ *    that is actually on disk, so nothing here ever jumps to another commit.
+ *
+ * Which of them exist is decided by `ImpactScopeResolver` from where HEAD is. On `main` (by BRANCH
+ * NAME, so a local main with unpushed commits still counts as main) and on a detached HEAD only the
+ * last commit exists — the fork point IS HEAD there, so the branch comparison would always be empty.
+ * On a feature branch with commits past its fork point both exist, the branch one first. On a FRESH
+ * feature branch (fork point = HEAD) only the branch one exists: falling through to "last commit"
+ * would show main's last PR as if it were the branch's own work.
+ *
+ * Per comparison:
  *  - BUILD INPUT is every transitive dependency of the affected set that is not itself affected:
  *    `ci` dependsOn `^build`, so they must exist as build output though their inputs did not change.
  *    nx restores them from cache when it has them and compiles them otherwise — which one happens is
  *    not knowable here, so nothing claims it. A pure downward walk over the graph's own edges.
- *
- *  - AFFECTED is `nx show projects --affected --base=<fork point> --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.
+ *  - 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. 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 base is the repo's existing merge-base computation (`DiffScope.detectBase` in rules-config:
- * `git merge-base HEAD origin/main`, falling back to `main`) — never NX_BASE/NX_HEAD, whose value
- * depends on whoever launched the process. The changed-file list is `DiffScope.getChangedFiles`, the
- * same base→working-tree diff (with untracked files) every code rule uses.
+ *    — 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.
  *
- * The answer changes per branch, so it never goes into the committed dependencies.html or
- * dependencies.json (both stay byte-stable across branches). It goes into a SIDECAR,
- * `architecture/.impact/dependencies.impact.js`: a plain script setting one window global, loaded
- * with `<script src>` — the one way a page opened straight from disk (file://) can read a
- * neighbouring file. The directory carries its own `.gitignore` containing `*`, which ignores the
- * directory and everything in it, so a consumer repo needs no gitignore edit and the PR gate's
- * "build left nothing uncommitted" check never sees it.
+ * 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,
+ * `architecture/.impact/dependencies.impact.js`: a plain script setting one window global,
+ * `window.__WP_IMPACT__ = { scans, defaultKind }`, loaded with `<script src>` — the one way a page
+ * opened straight from disk (file://) can read a neighbouring file. The directory carries its own
+ * `.gitignore` containing `*`, which ignores the directory and everything in it, so a consumer repo
+ * needs no gitignore edit and the PR gate's "build left nothing uncommitted" check never sees it.
  *
- * Both `architecture:generate` and `architecture:visualize` refresh it: the answer changes with the
- * branch, not with the architecture, so viewing the SAVED graph re-scans Impact against it without
- * regenerating anything else (#1158).
+ * `architecture:visualize` scans every comparison that exists. `architecture:generate` refreshes
+ * ONLY the branch comparison (`GENERATE_IMPACT_KINDS`) and never scans the last commit; on main or a
+ * detached HEAD that leaves nothing to write, so it removes the sidecar and the page says to run
+ * `pnpm arch:visualize`.
  *
- * Impact is a convenience. When nx or git cannot answer, NO sidecar is written (a stale one is
- * removed) and the page disables Impact with a one-line reason. It never fails generation.
+ * Impact is a convenience. When nx or git cannot answer any comparison, NO sidecar is written (a
+ * stale one is removed) and the page disables Impact with a one-line reason. It never fails
+ * generation.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImpactRefresh = exports.ImpactSidecar = exports.NxImpactScanner = exports.ProjectFileOwners = exports.NxCli = exports.ImpactUnavailable = exports.ImpactReport = exports.IMPACT_SIDECAR_SRC = exports.IMPACT_SIDECAR_FILE = exports.IMPACT_SIDECAR_DIR = void 0;
+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;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
@@ -51,10 +67,30 @@ const toError_1 = require("../toError");
 exports.IMPACT_SIDECAR_DIR = '.impact';
 exports.IMPACT_SIDECAR_FILE = 'dependencies.impact.js';
 exports.IMPACT_SIDECAR_SRC = `${exports.IMPACT_SIDECAR_DIR}/${exports.IMPACT_SIDECAR_FILE}`;
-/** The nx call is capped; a slow or wedged nx disables Impact instead of stalling generation. */
+/** Each nx call is capped; a slow or wedged nx disables that comparison instead of stalling generation. */
 const NX_TIMEOUT_MS = 15000;
-/** What the sidecar carries; the page reads it as `window.__WP_IMPACT__`. */
+/** The branch whose name means "there is no branch comparison here, only the last commit". */
+const MAIN_BRANCH = 'main';
+exports.NOTHING_CHANGED_ON_BRANCH = 'Nothing changed on this branch yet';
+exports.ROOT_COMMIT_REASON = "HEAD is the repository's first commit; there is no previous commit to compare against";
+exports.UNCOMMITTED_SUFFIX = ' + uncommitted changes';
+/** Which of the two comparisons a scan answers. */
+var ImpactKind;
+(function (ImpactKind) {
+    /** Fork point → working tree: "Changed on this branch". */
+    ImpactKind["BRANCH"] = "branch";
+    /** HEAD^ → working tree: "Last commit". */
+    ImpactKind["COMMIT"] = "commit";
+})(ImpactKind || (exports.ImpactKind = ImpactKind = {}));
+/** `architecture:visualize` scans every comparison that exists. */
+exports.VISUALIZE_IMPACT_KINDS = [ImpactKind.BRANCH, ImpactKind.COMMIT];
+/** `architecture:generate` refreshes the branch comparison only and never scans the last commit. */
+exports.GENERATE_IMPACT_KINDS = [ImpactKind.BRANCH];
+/** One scan as the sidecar carries it; the page reads `window.__WP_IMPACT__.scans`. */
 class ImpactReport {
+    kind;
+    label;
+    dirty;
     available;
     reason;
     base;
@@ -64,7 +100,15 @@ class ImpactReport {
     changedFiles;
     dependencies;
     globalFiles;
-    constructor(available, reason, base, 
+    constructor(kind, 
+    /** What the page says this scan compares, e.g. "Changed on this branch (since abc1234)". */
+    label, 
+    /** The working tree had uncommitted or untracked changes (they count in the scan). */
+    dirty, available, 
+    /** Why the scan is unavailable; for an available but EMPTY scan, the note the page shows. */
+    reason, 
+    /** The base's short sha ('' when there is none). */
+    base, 
     /** Affected AND owning a changed file (node ids). */
     touched, 
     /** Affected but owning no changed file (node ids): their ci re-runs. */
@@ -88,6 +132,9 @@ class ImpactReport {
      * legend names them. Empty when nx's file ownership was unavailable — then nothing is known.
      */
     globalFiles) {
+        this.kind = kind;
+        this.label = label;
+        this.dirty = dirty;
         this.available = available;
         this.reason = reason;
         this.base = base;
@@ -100,14 +147,138 @@ class ImpactReport {
     }
 }
 exports.ImpactReport = ImpactReport;
-/** A scan that could not produce an answer: no sidecar is written, only this reason printed. */
+/** The sidecar's one global: every scan, and the one the page shows first. */
+class ImpactSidecarData {
+    scans;
+    defaultKind;
+    constructor(scans, defaultKind) {
+        this.scans = scans;
+        this.defaultKind = defaultKind;
+    }
+}
+exports.ImpactSidecarData = ImpactSidecarData;
+/** A scan (or a whole plan) that could not produce an answer. */
 class ImpactUnavailable {
     reason;
-    constructor(reason) {
+    label;
+    constructor(reason, label = 'Impact') {
         this.reason = reason;
+        this.label = label;
     }
 }
 exports.ImpactUnavailable = ImpactUnavailable;
+/** One comparison to scan. `base` is a full sha; null when it does not exist (`reason` says why). */
+class ImpactComparison {
+    kind;
+    base;
+    label;
+    dirty;
+    reason;
+    constructor(kind, base, label, dirty, reason) {
+        this.kind = kind;
+        this.base = base;
+        this.label = label;
+        this.dirty = dirty;
+        this.reason = reason;
+    }
+}
+exports.ImpactComparison = ImpactComparison;
+/** The comparisons that exist where HEAD is, and which one the page shows first. */
+class ImpactPlan {
+    comparisons;
+    defaultKind;
+    constructor(comparisons, defaultKind) {
+        this.comparisons = comparisons;
+        this.defaultKind = defaultKind;
+    }
+}
+exports.ImpactPlan = ImpactPlan;
+/** The few git facts the resolver needs. Injected so specs never spawn git. */
+class ImpactGit {
+    /** The checked-out branch's short name; null on a detached HEAD (or without git). */
+    branch(root) {
+        return this.run(root, ['symbolic-ref', '--short', '-q', 'HEAD']);
+    }
+    /** The full sha `ref` names; null when it does not resolve (e.g. `HEAD^` on the first commit). */
+    sha(root, ref) {
+        return this.run(root, ['rev-parse', '--verify', '-q', `${ref}^{commit}`]);
+    }
+    /** `git status --porcelain` is non-empty: uncommitted or untracked work. */
+    dirty(root) {
+        return (this.run(root, ['status', '--porcelain']) ?? '') !== '';
+    }
+    /** HEAD's subject line ('' when unknown). */
+    subject(root) {
+        return this.run(root, ['log', '-1', '--format=%s', 'HEAD']) ?? '';
+    }
+    /** Trimmed stdout, or null on any failure. */
+    run(root, args) {
+        const result = (0, child_process_1.spawnSync)('git', args, { cwd: root, encoding: 'utf8', stdio: 'pipe' });
+        if (result.error !== undefined || result.status !== 0)
+            return null;
+        return result.stdout.trim();
+    }
+}
+exports.ImpactGit = ImpactGit;
+/**
+ * Decides which comparisons exist from where HEAD is (#1163):
+ *
+ * | where | comparisons | default |
+ * |---|---|---|
+ * | `main` (by branch NAME) | last commit | last commit |
+ * | detached HEAD | last commit | last commit |
+ * | feature branch with commits past the fork point | branch, last commit | branch |
+ * | fresh feature branch (fork point = HEAD) | branch | branch |
+ *
+ * HEAD with no parent leaves the last commit unavailable, with `ROOT_COMMIT_REASON`.
+ */
+class ImpactScopeResolver {
+    git;
+    diffScope;
+    constructor(git = new ImpactGit(), diffScope = new rules_config_1.DiffScope()) {
+        this.git = git;
+        this.diffScope = diffScope;
+    }
+    resolve(root) {
+        const head = this.git.sha(root, 'HEAD');
+        if (head === null)
+            return new ImpactUnavailable('git cannot resolve HEAD (not a git checkout, or git is unavailable)');
+        const branch = this.git.branch(root);
+        const dirty = this.git.dirty(root);
+        const commit = this.lastCommit(root, dirty);
+        // On main the decision is the branch NAME, never merge-base: unpushed commits still mean "last commit".
+        if (branch === null || branch === MAIN_BRANCH)
+            return new ImpactPlan([commit], ImpactKind.COMMIT);
+        const fork = this.diffScope.detectBase(root);
+        if (fork === null) {
+            const reason = 'no fork point: neither origin/main nor main resolves';
+            return new ImpactPlan([new ImpactComparison(ImpactKind.BRANCH, null, 'Changed on this branch', dirty, reason)], ImpactKind.BRANCH);
+        }
+        const onBranch = new ImpactComparison(ImpactKind.BRANCH, fork, `Changed on this branch (since ${this.short(fork)})${dirty ? exports.UNCOMMITTED_SUFFIX : ''}`, dirty, '');
+        // A fresh branch has no commit of its own: "last commit" would be main's last PR, not its work.
+        if (this.sameCommit(fork, head))
+            return new ImpactPlan([onBranch], ImpactKind.BRANCH);
+        return new ImpactPlan([onBranch, commit], ImpactKind.BRANCH);
+    }
+    lastCommit(root, dirty) {
+        const parent = this.git.sha(root, 'HEAD^');
+        if (parent === null)
+            return new ImpactComparison(ImpactKind.COMMIT, null, 'Last commit', dirty, exports.ROOT_COMMIT_REASON);
+        const subject = this.git.subject(root);
+        const label = `Changed since ${this.short(parent)}${subject === '' ? '' : ` — ${subject}`}` +
+            (dirty ? exports.UNCOMMITTED_SUFFIX : '');
+        return new ImpactComparison(ImpactKind.COMMIT, parent, label, dirty, '');
+    }
+    /** detectBase may hand back a full or an abbreviated sha; compare on the shorter of the two. */
+    sameCommit(a, b) {
+        const length = Math.min(a.length, b.length);
+        return length > 0 && a.slice(0, length) === b.slice(0, length);
+    }
+    short(sha) {
+        return sha.slice(0, 7);
+    }
+}
+exports.ImpactScopeResolver = ImpactScopeResolver;
 /** Runs the workspace's own nx CLI. Injected so specs never spawn nx. */
 class NxCli {
     /** stdout, or null when nx cannot be found, exits non-zero or exceeds the timeout. */
@@ -153,6 +324,49 @@ class ProjectFileOwners {
     }
 }
 exports.ProjectFileOwners = ProjectFileOwners;
+/**
+ * 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".
+ */
+class SharedOwners {
+    ownership;
+    pending = null;
+    constructor(ownership) {
+        this.ownership = ownership;
+    }
+    get() {
+        if (this.pending === null)
+            this.pending = this.load();
+        return this.pending;
+    }
+    async load() {
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- the second shade is optional
+        try {
+            return await this.ownership.owners();
+        }
+        catch (err) {
+            const error = (0, toError_1.toError)(err);
+            console.warn(`⚠️  Impact: nx file ownership unavailable (${error.message}); showing one shade`);
+            return new Map();
+        }
+    }
+}
+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;
+    }
+}
 class NxImpactScanner {
     diffScope;
     nx;
@@ -163,28 +377,48 @@ class NxImpactScanner {
         this.nx = nx;
         this.ownership = ownership;
     }
-    async scan(workspaceRoot, graph) {
-        const base = this.diffScope.detectBase(workspaceRoot);
+    /** Every comparison, in order, sharing one ownership map. */
+    async scanAll(workspaceRoot, graph, comparisons) {
+        const owners = new SharedOwners(this.ownership);
+        const results = [];
+        for (const comparison of comparisons)
+            results.push(await this.scan(workspaceRoot, graph, comparison, owners));
+        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)) {
+        const base = comparison.base;
         if (base === null)
-            return new ImpactUnavailable('no fork point: neither origin/main nor main resolves (or git is unavailable)');
+            return this.report(comparison, false, comparison.reason, '', 0, new ImpactSets());
         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`);
+            return new ImpactUnavailable(`nx show projects --affected failed or took over ${NX_TIMEOUT_MS / 1000}s`, comparison.label);
         const affectedSet = this.parse(json, graph);
         if (affectedSet === null)
-            return new ImpactUnavailable('nx show projects --affected printed something other than a JSON list');
+            return new ImpactUnavailable('nx show projects --affected printed something other than a JSON list', comparison.label);
         const options = new rules_config_1.ChangedFilesOptions();
         options.tsOnly = false;
         options.includeDeletions = true;
         const files = this.diffScope.getChangedFiles(workspaceRoot, base, undefined, options);
         const short = base.slice(0, 7);
         if (affectedSet.length === 0)
-            return new ImpactReport(false, `nothing affected since the fork point ${short}`, short, [], [], [], files.length, [], []);
-        const owners = await this.owners();
-        const touched = this.touched(affectedSet, files, owners);
+            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 inputs = this.buildInputs(affectedSet, graph);
-        return new ImpactReport(true, '', short, this.ids(touched), this.ids(rest), this.ids(inputs), files.length, this.ids(this.buildInputs(touched, graph)), this.globalFiles(files, owners));
+        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);
+    }
+    /**
+     * 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, changedFiles, short) {
+        if (changedFiles === 0 && comparison.kind === ImpactKind.BRANCH)
+            return exports.NOTHING_CHANGED_ON_BRANCH;
+        if (changedFiles === 0)
+            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) {
@@ -243,17 +477,8 @@ class NxImpactScanner {
             return null;
         }
     }
-    /** Ownership failing is not fatal: the set then shows in one shade, all "affected". */
-    async owners() {
-        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- the second shade is optional
-        try {
-            return await this.ownership.owners();
-        }
-        catch (err) {
-            const error = (0, toError_1.toError)(err);
-            console.warn(`⚠️  Impact: nx file ownership unavailable (${error.message}); showing one shade`);
-            return new Map();
-        }
+    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);
     }
     ids(projects) {
         return projects.map((project) => this.names.getNodeId(project));
@@ -263,14 +488,14 @@ exports.NxImpactScanner = NxImpactScanner;
 /** Writes (or removes) the sidecar, self-ignored, beside architecture/dependencies.html. */
 class ImpactSidecar {
     /** Never throws: a sidecar that cannot be written just leaves Impact disabled on the page. */
-    write(architectureDir, report) {
+    write(architectureDir, data) {
         const dir = path.join(architectureDir, exports.IMPACT_SIDECAR_DIR);
         // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- impact is optional; a write failure must never fail generation
         try {
             fs.mkdirSync(dir, { recursive: true });
-            fs.writeFileSync(path.join(dir, '.gitignore'), '# Written by architecture:generate and architecture:visualize. Per-branch data: never commit it.\n*\n', 'utf-8');
+            fs.writeFileSync(path.join(dir, '.gitignore'), '# Written by architecture:generate and architecture:visualize. Per-checkout data: never commit it.\n*\n', 'utf-8');
             const file = path.join(dir, exports.IMPACT_SIDECAR_FILE);
-            fs.writeFileSync(file, this.script(report), 'utf-8');
+            fs.writeFileSync(file, this.script(data), 'utf-8');
             return file;
         }
         catch (err) {
@@ -279,48 +504,75 @@ class ImpactSidecar {
             return null;
         }
     }
-    /** A stale sidecar from an earlier branch must never be shown as this branch's impact. */
+    /** A stale sidecar from an earlier checkout must never be shown as this one's impact. */
     remove(architectureDir) {
         fs.rmSync(path.join(architectureDir, exports.IMPACT_SIDECAR_DIR, exports.IMPACT_SIDECAR_FILE), { force: true });
     }
-    script(report) {
-        const json = JSON.stringify(report).replace(/</g, '\\u003c');
-        return `// Generated by architecture:generate or architecture:visualize for one branch. Gitignored; do not commit.\nwindow.__WP_IMPACT__ = ${json};\n`;
+    script(data) {
+        const json = JSON.stringify(data).replace(/</g, '\\u003c');
+        return `// Generated by architecture:generate or architecture:visualize for one checkout. Gitignored; do not commit.\nwindow.__WP_IMPACT__ = ${json};\n`;
     }
 }
 exports.ImpactSidecar = ImpactSidecar;
-/** The generator's one call: scan, write, and report the result and its cost in one line. */
+/** The executors' one call: resolve, scan each comparison, write, and report one line per comparison. */
 class ImpactRefresh {
     scanner;
     sidecar;
-    constructor(scanner = new NxImpactScanner(), sidecar = new ImpactSidecar()) {
+    resolver;
+    constructor(scanner = new NxImpactScanner(), sidecar = new ImpactSidecar(), resolver = new ImpactScopeResolver()) {
         this.scanner = scanner;
         this.sidecar = sidecar;
+        this.resolver = resolver;
     }
-    /** Never throws — Impact is optional, generation is not. */
-    async run(architectureDir, workspaceRoot, graph) {
+    /**
+     * Scans the comparisons in `kinds` that exist here (`VISUALIZE_IMPACT_KINDS` /
+     * `GENERATE_IMPACT_KINDS`). Never throws — Impact is optional, generation is not.
+     */
+    async run(architectureDir, workspaceRoot, graph, kinds) {
         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 {
-            const report = await this.scanner.scan(workspaceRoot, graph);
+            const plan = this.resolver.resolve(workspaceRoot);
+            if (plan instanceof ImpactUnavailable)
+                return this.none(architectureDir, plan.reason, started);
+            const comparisons = plan.comparisons.filter((comparison) => kinds.includes(comparison.kind));
+            if (comparisons.length === 0)
+                return this.none(architectureDir, 'no Changed-on-this-branch comparison on main or a detached HEAD; pnpm arch:visualize shows the last commit', started);
+            const results = await this.scanner.scanAll(workspaceRoot, graph, comparisons);
+            const lines = results.map((result) => this.line(result));
+            const scans = results.filter((result) => result instanceof ImpactReport);
             const cost = `${Date.now() - started} ms`;
-            if (report instanceof ImpactUnavailable) {
+            if (scans.length === 0) {
                 this.sidecar.remove(architectureDir);
-                return `ℹ️  Impact disabled, no sidecar written: ${report.reason} (${cost})`;
+                return [...lines, `ℹ️  Impact disabled, no sidecar written (${cost})`].join('\n');
             }
-            const file = this.sidecar.write(architectureDir, report);
-            if (file === null)
-                return `⚠️  Impact sidecar not written (${cost})`;
-            if (!report.available)
-                return `ℹ️  Impact disabled on the page: ${report.reason} (${cost})`;
-            return (`✅ Impact vs ${report.base}: ${report.touched.length} touched · ${report.affected.length} affected · ` +
-                `${report.buildInputs.length} build inputs, from ${report.changedFiles} changed file(s) (${cost}) → ${file}`);
+            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');
         }
         catch (err) {
             const error = (0, toError_1.toError)(err);
             return `⚠️  Impact skipped: ${error.message}`;
         }
     }
+    /** The plan's default when that scan is available, else the first available one. */
+    defaultKind(scans, preferred) {
+        const usable = scans.filter((scan) => scan.available);
+        if (usable.length === 0 || usable.some((scan) => scan.kind === preferred))
+            return preferred;
+        return usable[0].kind;
+    }
+    none(architectureDir, reason, started) {
+        this.sidecar.remove(architectureDir);
+        return `ℹ️  Impact disabled, no sidecar written: ${reason} (${Date.now() - started} ms)`;
+    }
+    line(result) {
+        if (result instanceof ImpactUnavailable || !result.available)
+            return `ℹ️  Impact · ${result.label}: unavailable — ${result.reason}`;
+        if (result.reason !== '')
+            return `✅ Impact · ${result.label}: ${result.reason}`;
+        return (`✅ Impact · ${result.label}: ${result.touched.length} touched · ${result.affected.length} affected · ` +
+            `${result.buildInputs.length} build inputs, from ${result.changedFiles} changed file(s)`);
+    }
 }
 exports.ImpactRefresh = ImpactRefresh;
 //# sourceMappingURL=graph-impact.js.map