canary-test-cli 7.0.0 → 7.2.0

package/dist/engine/guardian/cli.js

@@ -13,8 +13,8 @@
  *     `_branch_protection_client` seams were replaced.
  *   - Commands are THIN: parse -> call the already-ported guardian library ->
  *     emit. No business logic lives in a handler.
- *   - Business exit codes are carried by throwing {@link CliExit} (Python's
- *     `typer.Exit(n)`); `parseAsync` from a test catches it to read the code.
+ *   - Business exit codes are carried by throwing {@link CliExitError}
+ *     (Python's `typer.Exit(n)`); a test's `parseAsync` catches it to read it.
  *     `.exitOverride()` turns commander's own usage errors into throws too, so a
  *     test never terminates the process.
  *
@@ -52,13 +52,14 @@ import pc from 'picocolors';
 import { AuthoringContext, InSessionAgentProbe, InSessionAgentTier, decideBlock, } from './agent-tier.js';
 import { RestReactionsClient, collectAdjudications, loadAdjudicationRecords, renderPrecision, summarizePrecision, } from './adjudication.js';
 import { emitAnalysis } from './analysis-emit.js';
-import { gateOutcome } from '../core/gate-result.js';
+import { EXIT_ABSTAINED, gateOutcome, } from '../core/gate-result.js';
 import { coverageDegradedNotice, resolveCoverage, resolveCoverageWithInput, validateCoverageJson, } from './coverage.js';
 import { buildApiDelta, writeApiDelta } from './delta-emitter.js';
 import { extractApiDiff } from './diff-extractor.js';
 import { HardGateAbstained, HardGateBlocked, RestBranchProtectionClient, applyHardGate, renderPlaybook, } from './hard-gate.js';
 import { mapImpact } from './impact-mapper.js';
-import { applySuppressions, buildFindings, buildWeakTestFindings, computeExitCode, effectiveGraphDepth, filterHeuristicNoise, filterSkipped, filterTestSupportUnits, filterTestUnits, filterTypeOnlyUnits, findReexportOnly, loadGuardianConfig, render, scopeDiff, } from './pr-check.js';
+import { ensureAscii } from '../util/ensure-ascii.js';
+import { MERGE_REF_WARNING, provenanceLine, applySuppressions, buildFindings, buildWeakTestFindings, computeExitCode, effectiveGraphDepth, filterHeuristicNoise, filterSkipped, filterTestSupportUnits, filterTestUnits, filterTypeOnlyUnits, findReexportOnly, isCoverageAbstention, loadGuardianConfig, renderFindings, scopeDiff, } from './pr-check.js';
 import { RestGitHubClient, degradationAnnotation, upsertStickyComment, } from './pr-comment.js';
 import { buildSummary } from './summary-emitter.js';
 import { resolveTier } from './tier.js';
@@ -71,12 +72,12 @@ const CROSS = '\u{2717}';
  * Business exit signal. Thrown from a handler to carry an exit code the way
  * Python's `typer.Exit(code)` did; the runner catches it to read the code.
  */
-export class CliExit extends Error {
+export class CliExitError extends Error {
     code;
     constructor(code) {
         super(`exit ${code}`);
         this.code = code;
-        this.name = 'CliExit';
+        this.name = 'CliExitError';
     }
 }
 /**
@@ -94,10 +95,10 @@ function normalizeUsageExit(err) {
     throw err;
 }
 /** Raised by `deps.sleep` to break the `watch` poll loop (Ctrl+C analog). */
-export class WatchInterrupt extends Error {
+export class WatchInterruptError extends Error {
     constructor() {
         super('watch interrupted');
-        this.name = 'WatchInterrupt';
+        this.name = 'WatchInterruptError';
     }
 }
 /** Process-backed defaults for production (the `guardianCommand` export). */
@@ -148,21 +149,6 @@ export function defaultDeps() {
         sleep: (secs) => new Promise((resolve) => setTimeout(resolve, secs * 1000)),
     };
 }
-/**
- * Escape non-ASCII to `\uXXXX`, matching Python `json.dumps(ensure_ascii=True)`.
- */
-function ensureAscii(json) {
-    // Escape every UTF-16 code UNIT >= 0x80 to \uXXXX, matching Python
-    // json.dumps(ensure_ascii=True). Iterating by unit (not code point) means an
-    // astral char's surrogate pair emits \udXXX\udXXX, like Python; a code-point
-    // regex would stop at U+FFFF and leave astral chars raw.
-    let out = '';
-    for (let i = 0; i < json.length; i++) {
-        const c = json.charCodeAt(i);
-        out += c >= 0x80 ? '\\u' + c.toString(16).padStart(4, '0') : json[i];
-    }
-    return out;
-}
 /** ISO-8601 UTC timestamp with a `+00:00` offset (Python `isoformat`-shaped). */
 function isoUtcNow() {
     return new Date().toISOString().replace('Z', '+00:00');
@@ -212,8 +198,9 @@ export function prContextFromEnv(env) {
  * the contributor's branch and stays resolvable.
  *
  * Returns `null` rather than a partial URL whenever repo or SHA is missing, so
- * {@link render} falls back to plain code text. That degradation is deliberate:
- * an unresolvable link still *looks* clickable, which is worse than no link.
+ * {@link renderFindings} falls back to plain code text. That degradation is
+ * deliberate: an unresolvable link still *looks* clickable, which is worse than
+ * no link.
  */
 export function blobBaseFromEnv(env) {
     const repo = env['GITHUB_REPOSITORY'];
@@ -387,6 +374,59 @@ function readWorktreeDiff(deps) {
         return unstaged;
     return deps.runGit(['diff', '--staged'])?.stdout ?? '';
 }
+/**
+ * The PR head sha the CI event declares, if this is a `pull_request` event.
+ *
+ * Distinct from {@link eventBaseSha}: that answers "what are we diffing
+ * against", this answers "what SHOULD the diffed HEAD be". They are compared in
+ * {@link detectMergeRef} (#761).
+ */
+function eventHeadSha(env) {
+    const eventPath = env['GITHUB_EVENT_PATH'];
+    if (!eventPath)
+        return null;
+    let sha;
+    try {
+        const event = JSON.parse(readFileSync(eventPath, 'utf-8'));
+        sha = event?.pull_request?.head?.sha;
+    }
+    catch {
+        return null;
+    }
+    return typeof sha === 'string' && sha.trim() ? sha.trim() : null;
+}
+/** Resolve `HEAD` to a full sha, or null when git cannot answer. */
+function resolveHeadSha(deps) {
+    const res = deps.runGit(['rev-parse', 'HEAD']);
+    if (res === null || res.code !== 0)
+        return null;
+    const sha = res.stdout.trim();
+    return sha || null;
+}
+/**
+ * True when the checked-out HEAD is a `pull_request` MERGE REF, not the PR head.
+ *
+ * This is the merge-ref diff defect (#761). `actions/checkout` on a
+ * `pull_request` event checks out `refs/pull/<n>/merge` — the base branch
+ * merged with the PR head — unless the caller passes an explicit `ref`. Any
+ * diff taken to that HEAD includes every commit merged into the base branch
+ * since the base sha, because the triple-dot merge base degenerates to the base
+ * sha itself (it is an ancestor of the merge commit). A one-file docs PR was
+ * analyzed as 43 files that way.
+ *
+ * Detection is a comparison, not a heuristic: the event payload states the PR
+ * head sha outright, so a HEAD that differs from it is diffing something else.
+ * Returns false whenever either side is unknown — an undetectable case must not
+ * masquerade as a detected-clean one.
+ */
+export function detectMergeRef(headSha, deps) {
+    if (deps.env['GITHUB_EVENT_NAME'] !== 'pull_request')
+        return false;
+    const declared = eventHeadSha(deps.env);
+    if (!declared || !headSha)
+        return false;
+    return declared !== headSha;
+}
 /** True when the process looks like a CI runner rather than a dev worktree. */
 function isCiContext(env) {
     return Boolean(env['GITHUB_ACTIONS'] || env['CI']);
@@ -483,6 +523,11 @@ export function readPrDiff(source, deps) {
     }
     return { text: readWorktreeDiff(deps), origin: 'worktree', base: null };
 }
+// Built from the shared fragment so the annotation and the rendered provenance
+// line cannot drift into describing the same defect two different ways (#761).
+const MERGE_REF_NOTICE = `guardian: ${MERGE_REF_WARNING} — findings may name files this PR never ` +
+    'touched. Check out with `ref: ${{ github.event.pull_request.head.sha }}`, ' +
+    'or diff to that sha instead of HEAD.';
 const EMPTY_CI_DIFF_NOTICE = 'guardian: 0 changed paths — fell back to a working-tree `git diff`, which ' +
     'is empty on a clean CI checkout, so NOTHING was verified. Pass ' +
     '`--diff <base>...<head>`, or checkout with `fetch-depth: 0` so the PR base ' +
@@ -513,7 +558,7 @@ function warnIfEmptyCiDiff(resolved, unitCount, deps) {
 function loadSpec(path, deps) {
     if (!existsSync(path)) {
         deps.err(`Spec file not found: ${path}`);
-        throw new CliExit(2);
+        throw new CliExitError(2);
     }
     const text = readFileSync(path, 'utf-8');
     // Python `_load_spec`: `.json` -> json.loads; otherwise yaml.safe_load (with a
@@ -627,16 +672,16 @@ function validateCoverageCmd(path, opts, deps) {
         const st = statSync(path);
         if (st.isDirectory() || st.size > MAX_COVERAGE_BYTES) {
             deps.out(`${pc.red(pc.bold(`${CROSS} cannot read ${path}:`))} not a readable file within the size limit`);
-            throw new CliExit(2);
+            throw new CliExitError(2);
         }
         text = readFileSync(path, 'utf-8');
     }
     catch (exc) {
-        if (exc instanceof CliExit)
+        if (exc instanceof CliExitError)
             throw exc;
         const msg = exc instanceof Error ? exc.message : String(exc);
         deps.out(`${pc.red(pc.bold(`${CROSS} cannot read ${path}:`))} ${msg}`);
-        throw new CliExit(2);
+        throw new CliExitError(2);
     }
     let data;
     try {
@@ -645,7 +690,7 @@ function validateCoverageCmd(path, opts, deps) {
     catch (exc) {
         const msg = exc instanceof Error ? exc.message : String(exc);
         deps.out(`${pc.red(pc.bold(`${CROSS} ${path} is not valid JSON:`))} ${msg}`);
-        throw new CliExit(2);
+        throw new CliExitError(2);
     }
     const problems = validateCoverageJson(data);
     const errors = problems.filter((p) => p.severity === 'error');
@@ -692,7 +737,7 @@ function validateCoverageCmd(path, opts, deps) {
         }
     }
     if (errors.length > 0 || (opts.strict && warnings.length > 0)) {
-        throw new CliExit(1);
+        throw new CliExitError(1);
     }
 }
 /**
@@ -713,7 +758,7 @@ async function hardenGateCmd(opts, deps) {
     const repo = opts.repo;
     if (!repo) {
         deps.out(`${pc.red(pc.bold(`${CROSS} no repo`))} ${EM_DASH} pass --repo owner/repo or set GITHUB_REPOSITORY.`);
-        throw new CliExit(2);
+        throw new CliExitError(2);
     }
     const playbook = renderPlaybook(repo, opts.branch, opts.check);
     // #490: the readiness evidence the promotion is supposed to rest on.
@@ -730,7 +775,7 @@ async function hardenGateCmd(opts, deps) {
     if (!opts.token) {
         deps.out(`${pc.red(pc.bold(`${CROSS} --apply needs an admin token`))} (pass --token or set GITHUB_TOKEN).\n`);
         deps.out(playbook);
-        throw new CliExit(2);
+        throw new CliExitError(2);
     }
     const client = deps.buildBranchProtectionClient(repo, opts.token);
     let plan;
@@ -745,12 +790,12 @@ async function hardenGateCmd(opts, deps) {
             deps.out(outcome.summaryLine);
             deps.out(`${pc.red(pc.bold(`${CROSS} ${exc.reason}`))}\n`);
             deps.out(exc.playbook);
-            throw new CliExit(outcome.exitCode); // 3, never 1
+            throw new CliExitError(outcome.exitCode); // 3, never 1
         }
         if (exc instanceof HardGateBlocked) {
             deps.out(`${pc.red(pc.bold(`${CROSS} ${exc.reason}`))}\n`);
             deps.out(exc.playbook);
-            throw new CliExit(1);
+            throw new CliExitError(1);
         }
         throw exc;
     }
@@ -785,7 +830,7 @@ async function collectAdjudicationsCmd(opts, deps) {
     }
     if (!repo || prNumber === undefined) {
         deps.out(`${pc.red(pc.bold(`${CROSS} no PR context`))} ${EM_DASH} pass --repo and --pr, or run in Actions.`);
-        throw new CliExit(2);
+        throw new CliExitError(2);
     }
     const client = deps.buildReactionsClient(repo, prNumber);
     const res = await collectAdjudications(client, {
@@ -811,7 +856,7 @@ async function collectAdjudicationsCmd(opts, deps) {
     }
     if (res.action === 'unavailable') {
         deps.out(pc.red(pc.bold(`${CROSS} ${res.notice ?? 'not persisted'}`)));
-        throw new CliExit(1);
+        throw new CliExitError(1);
     }
 }
 /** Aggregate the persisted adjudications into the promotion evidence (#490). */
@@ -835,7 +880,7 @@ function precisionCmd(opts, deps) {
  * read-only-token degradation is surfaced LOUDLY.
  */
 async function postStickyComment(findings, resolution, deps, gateMeta = null) {
-    const body = render(findings, 'comment', resolution.effective, resolution.degraded_notice, gateMeta, blobBaseFromEnv(deps.env));
+    const body = renderFindings(findings, 'comment', resolution.effective, resolution.degraded_notice, gateMeta, blobBaseFromEnv(deps.env));
     const ctx = prContextFromEnv(deps.env);
     if (ctx === null) {
         deps.out(`guardian: no PR context in env ${EM_DASH} printing instead.`);
@@ -890,11 +935,18 @@ const PR_CHECK_ABSTAIN_REMEDIATION = [
         'every path.',
 ];
 /** Exit 3 with the structural abstention line + remediation (#508). */
-function abstainPrCheck(skipped, format, deps) {
+function abstainPrCheck(skipped, format, deps, provenance = null) {
     const outcome = gateOutcome({ checked: 0, findings: [], skipped }, 'gate', {
         noun: 'unit(s)',
     });
     deps.out(outcome.summaryLine);
+    // #761: an abstention says "I verified zero items" — the immediate next
+    // question is "over WHAT?", and the run that motivated this feature is
+    // precisely one that should have abstained. Stating the range here is what
+    // separates "correctly abstained on a docs-only PR" from "abstained because
+    // the diff was wrong", which read identically without it.
+    if (provenance)
+        deps.out(provenanceLine(provenance));
     for (const line of PR_CHECK_ABSTAIN_REMEDIATION)
         deps.out(line);
     if (format === 'json') {
@@ -903,9 +955,18 @@ function abstainPrCheck(skipped, format, deps) {
         // to. Without it a consumer sees `abstained: true` and cannot tell
         // WHAT was dropped or why -- the #508 class one layer down, on the
         // only surface a machine can read.
-        { findings: [], tier: 0, checked: 0, abstained: true, skipped }, null, 2)));
+        {
+            findings: [],
+            tier: 0,
+            checked: 0,
+            abstained: true,
+            skipped,
+            // #761: `null` when no diff was resolved -- never absent, so a
+            // reader can tell "not applicable" from "this producer is old".
+            provenance,
+        }, null, 2)));
     }
-    throw new CliExit(outcome.exitCode); // EXIT_ABSTAINED
+    throw new CliExitError(outcome.exitCode); // EXIT_ABSTAINED
 }
 /** Resolve the analyses-channel dir (test override, else repo-root default). */
 function resolveAnalysesDir(override, deps) {
@@ -968,7 +1029,7 @@ async function prCheckCmd(opts, deps) {
     // entirely (no diff scoped, no comment posted, exit 0).
     if (opts.postComment && !config.pr_enabled) {
         deps.out(`guardian: pr.enabled is false ${EM_DASH} skipping PR surface.`);
-        throw new CliExit(0);
+        throw new CliExitError(0);
     }
     const effectiveGate = opts.gate ?? config.pr_gate;
     // #490: read reviewer 👍/👎 off the PREVIOUS run's sticky comment before this
@@ -983,6 +1044,27 @@ async function prCheckCmd(opts, deps) {
     const diffText = resolvedDiff.text;
     const units = scopeDiff(diffText);
     warnIfEmptyCiDiff(resolvedDiff, units.length, deps);
+    // #761: capture what the diff was taken between, BEFORE the skip/test/
+    // type-only filters run — `fileCount` is the size of the surface guardian was
+    // handed, which is the number a reviewer can check against their own PR.
+    // Populated even for an explicit `--diff` (where `base` is unknowable): the
+    // merge-ref warning and the file count are exactly what was missing on
+    // the consumer run that surfaced #761, which passed `--diff` from a file.
+    const headSha = resolveHeadSha(deps);
+    const mergeRef = detectMergeRef(headSha, deps);
+    const provenance = {
+        base: resolvedDiff.base,
+        head: headSha,
+        origin: resolvedDiff.origin,
+        fileCount: units.length,
+        ...(mergeRef ? { mergeRef: true } : {}),
+    };
+    if (mergeRef) {
+        // Loud, because it invalidates every count downstream — but non-blocking:
+        // the caller owns the checkout, so guardian reports and carries on.
+        deps.err(degradationAnnotation(MERGE_REF_NOTICE));
+        appendStepSummary(deps.env, MERGE_REF_NOTICE);
+    }
     // SC-2: drop docs/config-only units matching skipGlobs.
     const [keptSkip, skipped] = filterSkipped(units, config.skip_globs);
     // FIX A: drop test-path units -- a test does not itself need a test.
@@ -1013,7 +1095,7 @@ async function prCheckCmd(opts, deps) {
     // number on this path.
     const preCoverageSkips = prCheckSkipEntries(skipped, testUnits, barrelUnits, supportUnits, typeOnlyUnits);
     if (kept.length === 0 && weakFindings.length === 0) {
-        abstainPrCheck(preCoverageSkips, opts.format, deps);
+        abstainPrCheck(preCoverageSkips, opts.format, deps, provenance);
     }
     const { results, coverage } = resolveCoverageWithInput(kept, {
         coveragePath: opts.coverage ?? null,
@@ -1039,7 +1121,7 @@ async function prCheckCmd(opts, deps) {
     // SKIP rather than rendering an empty "0 unaddressed" report -- an adopter
     // must be able to tell "nothing was judgeable" from "everything passed".
     if (scoredResults.length === 0 && findings.length === 0) {
-        abstainPrCheck(allSkips, opts.format, deps);
+        abstainPrCheck(allSkips, opts.format, deps, provenance);
     }
     // SC-5 (PR half): resolve the requested tier against actual capability. No
     // agent runtime exists (default NoAgentProbe), so any `pr.tier > 0` drops to
@@ -1049,15 +1131,26 @@ async function prCheckCmd(opts, deps) {
         deps.out(degradationAnnotation(resolution.degraded_notice));
         appendStepSummary(deps.env, resolution.degraded_notice);
     }
+    // #761: the run judged units but VERIFIED no coverage, and every finding is a
+    // naming guess. That is an abstention on the coverage denominator — a
+    // different test from the findings-eligible one the two `abstainPrCheck`
+    // calls above make, and the one that consumer run needed. It does not exit
+    // through `abstainPrCheck`: those findings are worth showing, so the run keeps
+    // every surface and changes only its headline and its exit code.
+    const coverageAbstained = isCoverageAbstention(coverage, findings);
     // Compute the gate result once, up front: the emitted record carries it and it
     // is the process exit at the end (SC-4 -- emit never changes the exit logic).
-    const exitCode = computeExitCode(findings, effectiveGate);
+    const exitCode = coverageAbstained
+        ? EXIT_ABSTAINED
+        : computeExitCode(findings, effectiveGate);
     // #554: every surface below carries the coverage-input state, so a run that
     // never saw a coverage report cannot present as one that checked and passed.
     const gateMeta = {
         checked: scoredResults.length,
-        abstained: false,
+        abstained: coverageAbstained,
         coverage,
+        // #761: the endpoints every count above is scoped by.
+        provenance,
         // #582: `checked` is the numerator of a fraction whose denominator was
         // never printed. This is the rest of it.
         skipped: allSkips,
@@ -1085,9 +1178,15 @@ async function prCheckCmd(opts, deps) {
             degraded_notice: resolution.degraded_notice,
             exit_code: exitCode,
             checked: scoredResults.length,
-            abstained: false, // an abstained run exits before emit (see plan)
+            // #761: a coverage abstention DOES reach emit — unlike the
+            // findings-eligible abstention, it keeps its findings, so a machine
+            // consumer must see the flag rather than infer a result from the array.
+            abstained: coverageAbstained,
             coverage,
             skipped: allSkips,
+            // #761: the archived artifact is where an inflated diff gets diagnosed
+            // long after the run, so it carries the endpoints too.
+            provenance,
         });
         if (res.action === 'emitted') {
             deps.out(`guardian: wrote analysis record ${RIGHT_ARROW} ${res.path}`);
@@ -1109,9 +1208,9 @@ async function prCheckCmd(opts, deps) {
     }
     else if (!opts.emitAnalysis && !opts.postComment) {
         // Local, non-posting default: render to stdout in `--format`.
-        deps.out(render(findings, opts.format, resolution.effective, resolution.degraded_notice, gateMeta, blobBaseFromEnv(deps.env)));
+        deps.out(renderFindings(findings, opts.format, resolution.effective, resolution.degraded_notice, gateMeta, blobBaseFromEnv(deps.env)));
     }
-    throw new CliExit(exitCode);
+    throw new CliExitError(exitCode);
 }
 // --- author-plan --------------------------------------------------------------
 /**
@@ -1246,7 +1345,7 @@ async function watchCmd(opts, deps) {
         }
     }
     catch (exc) {
-        if (exc instanceof WatchInterrupt) {
+        if (exc instanceof WatchInterruptError) {
             deps.out(`\n${pc.yellow('Watch stopped.')}`);
             return;
         }
@@ -1262,7 +1361,7 @@ function collect(value, previous) {
  * Build a fresh `guardian` command wired to `depsInit` (process-backed defaults
  * fill any gap). Every subcommand uses `.exitOverride()` so a usage error throws
  * a `CommanderError` rather than terminating the process -- tests read the exit
- * code from the thrown error (or from {@link CliExit} for business exits).
+ * code from the thrown error (or from {@link CliExitError} for business exits).
  */
 export function createGuardianCommand(depsInit = {}) {
     const deps = { ...defaultDeps(), ...depsInit };

package/dist/engine/guardian/coverage.js

@@ -36,7 +36,7 @@ export { coverageLimits } from './diff-coverage/formats/cobertura.js';
 export { parseCoverageJson } from './diff-coverage/formats/coverage-json.js';
 export { validateCoverageJson, } from './diff-coverage/formats/coverage-json-lint.js';
 export { resolveFromGraph } from './diff-coverage/graph-tier.js';
-export { resolveHeuristic } from './diff-coverage/heuristic-tier.js';
+export { resolveFromHeuristic } from './diff-coverage/heuristic-tier.js';
 export { coverageDegradedNotice, coverageStatus, resolveCoverage, resolveCoverageWithInput, } from './diff-coverage/orchestrator.js';
 export { isSourcePath, isTestPath, isTestSupportPath, } from './diff-coverage/paths.js';
 export { resolveFromReport } from './diff-coverage/report-tier.js';

package/dist/engine/guardian/diff-coverage/heuristic-tier.js

@@ -109,7 +109,7 @@ function iterTestFiles(repoRoot) {
  * A unit is heuristic-covered iff some test file under `repoRoot` references
  * the unit's file stem or a top-level symbol name (word-boundary scan).
  */
-export function resolveHeuristic(units, repoRoot = '.') {
+export function resolveFromHeuristic(units, repoRoot = '.') {
     const testFiles = iterTestFiles(repoRoot);
     const results = [];
     for (const unit of units) {

package/dist/engine/guardian/diff-coverage/orchestrator.js

@@ -4,7 +4,7 @@
  * clean" from "never checked".
  */
 import { resolveFromGraph } from './graph-tier.js';
-import { resolveHeuristic } from './heuristic-tier.js';
+import { resolveFromHeuristic } from './heuristic-tier.js';
 import { matchUnitsToIndex, readReportIndex } from './report-tier.js';
 /**
  * SC-3 orchestrator: resolve each unit at the highest available fidelity.
@@ -116,7 +116,7 @@ export function resolveCoverageWithInput(units, options = {}) {
         }
     }
     if (remaining.length > 0) {
-        for (const r of resolveHeuristic(remaining, repoRoot)) {
+        for (const r of resolveFromHeuristic(remaining, repoRoot)) {
             resolved.set(r.unit, r);
         }
     }