@nielspeter/eess 0.2.2 → 0.5.0

package/dist/unsuppressable.js

@@ -0,0 +1,76 @@
+/**
+ * The one sentence that tells a reader a configuration finding has no escape
+ * hatch — [ADR-009](../../../adr/009-agent-first-failure-surfaces.md) rule 3.
+ *
+ * Stated on the finding rather than inside each remedy so the per-shape advice
+ * stays one sentence each and this stays one sentence in one place. Measured
+ * before it existed: a reader given only the remedy tries `.asSeverity('warn')`,
+ * `.excluding()`, the baseline and `--changed` — four CI cycles — because
+ * nothing told them those were refused.
+ *
+ * ## Why it lives here rather than inline
+ *
+ * It was written twice, inline, at two sites in `terminal-builder.ts`, and
+ * prettier had already split the second copy across lines. Two copies of a
+ * sentence that enumerates a list is the shape that goes stale: the code grew a
+ * sixth refusing surface and both copies still named five.
+ *
+ * ## The list is a claim, so it is guarded
+ *
+ * `tests/core/unsuppressable-sentence.test.ts` derives the refusing mechanisms
+ * **behaviourally** — one probe each — and compares that set against the names
+ * parsed out of this string. Disagreement fails in both directions: naming a
+ * mechanism that does not refuse (bug 0017's shape) and refusing by a mechanism
+ * this does not name. The second is what actually happened.
+ *
+ * The sixth surface is the inline `// eess-exclude` comment, refused in
+ * `execute-rule.ts` by the `v.bypassFilters === true ||` clause. It was omitted
+ * while it was hard to reach; [ts-archunit bug 0041](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0041-an-exclusion-comment-is-a-no-op-for-most-conditions.md)
+ * made inline comments work for every condition family, so an agent reading a
+ * five-item list and inferring exhaustiveness now reaches for the one mechanism
+ * the sentence forgot to mention.
+ */
+export const UNSUPPRESSABLE = "This finding cannot be suppressed: not by .warn(), .asSeverity('warn'), " +
+    '.excluding(), a `// eess-exclude` comment, a baseline, or diff-aware mode. ' +
+    // The seventh thing an agent tries, and the one you least want it to learn.
+    // Measured: `recommended(p)` over a mis-scoped project reports four findings,
+    // each carrying the sentence above; adding `overrides: { id: 'off' }` reports
+    // three. One config line removed a finding that had just told the reader, in a
+    // sentence guarded by a parity test, that it could not be removed.
+    //
+    // Naming it here rather than leaving it discoverable by elimination: an agent
+    // that hits six walls and then finds `'off'` documented in `docs/presets.md`
+    // will stamp it, which is ADR-009 rule 1's trained-suppression dynamic produced
+    // by our own gate. It is NOT added to `UNSUPPRESSABLE_MECHANISMS`, because that
+    // list is the set the parity guard proves DO refuse — and this one does not.
+    "A preset's overrides: { id: 'off' } does remove it, by deleting the rule " +
+    'entirely — that is not a suppression, it is a permanent decision that never expires.';
+/**
+ * The declaration half, appended ONLY by the zero-examined producer.
+ *
+ * It used to live in {@link UNSUPPRESSABLE}, which every configuration finding
+ * carries — so it was stapled to findings a declaration cannot settle. Measured:
+ * on the assertion-gate finding ("this detector has no pattern") and on a dead
+ * selector glob, adding `.expectEmpty()` changes nothing, because both are
+ * decided before any declaration is consulted. The reader declares, re-runs, and
+ * gets the identical failure with the identical advice — ADR-009 rule 2's loop,
+ * introduced by the sentence written to close one.
+ *
+ * On the dead-glob kind it was worse than a no-op: there `overrides: { id: 'off' }`
+ * IS the working exit and declaring is not, so the message steered the reader off
+ * the only door that opens.
+ *
+ * Zero-examined is the one kind a declaration actually settles.
+ */
+export const DECLARE_INSTEAD = 'If the rule genuinely has nothing to check, declare that instead — a declaration ' +
+    'is an assertion that expires, where deleting the rule is not.';
+/** The mechanism names the sentence claims to refuse, for the parity guard. */
+export const UNSUPPRESSABLE_MECHANISMS = [
+    '.warn()',
+    ".asSeverity('warn')",
+    '.excluding()',
+    '// eess-exclude',
+    'baseline',
+    'diff-aware',
+];
+//# sourceMappingURL=unsuppressable.js.map

package/dist/unsuppressable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsuppressable.js","sourceRoot":"","sources":["../src/unsuppressable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,cAAc,GACzB,0EAA0E;IAC1E,6EAA6E;IAC7E,4EAA4E;IAC5E,8EAA8E;IAC9E,8EAA8E;IAC9E,+EAA+E;IAC/E,mEAAmE;IACnE,EAAE;IACF,8EAA8E;IAC9E,6EAA6E;IAC7E,gFAAgF;IAChF,gFAAgF;IAChF,6EAA6E;IAC7E,2EAA2E;IAC3E,sFAAsF,CAAA;AAExF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,eAAe,GAC1B,mFAAmF;IACnF,+DAA+D,CAAA;AAEjE,+EAA+E;AAC/E,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,SAAS;IACT,qBAAqB;IACrB,cAAc;IACd,iBAAiB;IACjB,UAAU;IACV,YAAY;CACJ,CAAA"}

package/dist/vacuity-findings.d.ts

@@ -0,0 +1,49 @@
+import type { ArchViolation } from './violation.js';
+import type { RuleDescription } from './rule-description.js';
+/**
+ * What a rule can be asked about itself, without running it.
+ *
+ * Every finding here is a function of these three and nothing else — none of
+ * them evaluates the rule. That is what let them leave `TerminalBuilder`: they
+ * were never terminal behaviour, they were explanations OF it.
+ */
+export interface RuleFacts {
+    /** The builder's own class, for naming the rule in a finding. */
+    readonly ruleClass: {
+        name: string;
+    };
+    readonly reason: string | undefined;
+    describeRule(): RuleDescription;
+}
+export declare function zeroExaminedViolation(facts: RuleFacts): ArchViolation;
+/**
+ * The configuration finding for a rule that examined zero units BECAUSE one
+ * of its declared globs is diagnosably dead — `deadGlob` is the pre-formed
+ * reason a dialect's `RuleBuilder.deadGlobDiagnosis()` computed (a typo, an
+ * unanchored pattern, a directory glob pointed at a file — whatever the
+ * dialect's own glob-evaluation determined). Strictly more actionable than
+ * `zeroExaminedViolation()`'s generic message, which this replaces when a
+ * diagnosis is available; see `evidencedViolations()`.
+ */
+export declare function deadGlobViolation(facts: RuleFacts, deadGlob: string): ArchViolation;
+/**
+ * The configuration finding for a `.expectNonEmpty()` declaration that
+ * wasn't met — the corpus the author said should never be empty is empty
+ * right now. Overrides `assertsCardinality()`'s silent pass on purpose:
+ * the declaration is a stronger, caller-level claim than what the
+ * condition itself would otherwise tolerate.
+ */
+export declare function unmetExpectNonEmptyViolation(facts: RuleFacts): ArchViolation;
+/**
+ * The configuration finding for the ADR-010 part 3 precedence case: the
+ * family's own upstream source loaded nothing at all — a stronger claim
+ * than an ordinary dead selector, and worded accordingly (the fix is not
+ * "widen the selection", there is no selection yet to widen).
+ */
+export declare function zeroLoadedSourceViolation(facts: RuleFacts): ArchViolation;
+/**
+ * The configuration finding for a `.expectEmpty()` declaration that has
+ * expired — ADR-010 part 3: the number IS the finding, so it is named.
+ */
+export declare function expiredExpectEmptyViolation(facts: RuleFacts, examined: number): ArchViolation;
+//# sourceMappingURL=vacuity-findings.d.ts.map

package/dist/vacuity-findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vacuity-findings.d.ts","sourceRoot":"","sources":["../src/vacuity-findings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,iEAAiE;IACjE,QAAQ,CAAC,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,YAAY,IAAI,eAAe,CAAA;CAChC;AAuCD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAOrE;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAGnF;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAO5E;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAOzE;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAM7F"}

package/dist/vacuity-findings.js

@@ -0,0 +1,94 @@
+/**
+ * The configuration finding for a rule that examined zero units with no
+ * declared exemption — ADR-009 rule 2: named as a distinct cause (dead
+ * selector, empty corpus, or an unreachable examining seam), not folded
+ * into an ordinary violation message.
+ */
+/**
+ * The shape every configuration finding in this module shares.
+ *
+ * All five differ ONLY in their `message`, which `no-copy-paste` reported as one
+ * cluster at 100%. Extracting it puts the contract they have in common in one
+ * place, and that contract is load-bearing rather than incidental:
+ *
+ * - `bypassFilters: true` — a vacuity finding must survive `--changed`, a
+ *   baseline and an `eess-exclude`. A suppression mechanism that can suppress
+ *   the complaint about itself is not a mechanism.
+ * - `file: ''`, `line: 0` — there is no source position, because the fault is
+ *   the RULE, not a place in the code. That is also why the diff filter has to
+ *   exempt these explicitly (see `diff-aware.ts`).
+ * - `suggestion` is the message — its own remedy, never the author's (bug 0021).
+ */
+function configFinding(facts, message) {
+    const described = facts.describeRule();
+    const name = described.id ?? described.rule ?? facts.ruleClass.name;
+    return {
+        rule: described.rule ?? name,
+        ruleId: described.id,
+        element: name,
+        file: '',
+        line: 0,
+        message,
+        suggestion: message,
+        because: facts.reason,
+        bypassFilters: true,
+    };
+}
+export function zeroExaminedViolation(facts) {
+    const message = `this rule examined zero units. If this is expected (the corpus is legitimately ` +
+        `empty right now), declare it explicitly with .expectEmpty() — otherwise this is a ` +
+        `dead selector, an empty project, or a rule that never reaches its own examining ` +
+        `seam, and the fix is to widen the selection, not to suppress this finding.`;
+    return configFinding(facts, message);
+}
+/**
+ * The configuration finding for a rule that examined zero units BECAUSE one
+ * of its declared globs is diagnosably dead — `deadGlob` is the pre-formed
+ * reason a dialect's `RuleBuilder.deadGlobDiagnosis()` computed (a typo, an
+ * unanchored pattern, a directory glob pointed at a file — whatever the
+ * dialect's own glob-evaluation determined). Strictly more actionable than
+ * `zeroExaminedViolation()`'s generic message, which this replaces when a
+ * diagnosis is available; see `evidencedViolations()`.
+ */
+export function deadGlobViolation(facts, deadGlob) {
+    const message = `this rule examined zero units — ${deadGlob}`;
+    return configFinding(facts, message);
+}
+/**
+ * The configuration finding for a `.expectNonEmpty()` declaration that
+ * wasn't met — the corpus the author said should never be empty is empty
+ * right now. Overrides `assertsCardinality()`'s silent pass on purpose:
+ * the declaration is a stronger, caller-level claim than what the
+ * condition itself would otherwise tolerate.
+ */
+export function unmetExpectNonEmptyViolation(facts) {
+    const message = `this rule declared .expectNonEmpty() but examined zero units — the corpus this ` +
+        `rule asserted should never be empty is empty right now. If that's still true, fix ` +
+        `the selection (a glob typo, a missing folder); if the corpus legitimately can be ` +
+        `empty, remove .expectNonEmpty().`;
+    return configFinding(facts, message);
+}
+/**
+ * The configuration finding for the ADR-010 part 3 precedence case: the
+ * family's own upstream source loaded nothing at all — a stronger claim
+ * than an ordinary dead selector, and worded accordingly (the fix is not
+ * "widen the selection", there is no selection yet to widen).
+ */
+export function zeroLoadedSourceViolation(facts) {
+    const message = `this rule's source loaded zero units before any selection ran — an empty project, ` +
+        `an unreadable tsconfig, or a glob resolving to nothing. This outranks any ` +
+        `.expectEmpty() declaration and any condition satisfied by emptiness: fix the ` +
+        `project/source configuration, not the rule.`;
+    return configFinding(facts, message);
+}
+/**
+ * The configuration finding for a `.expectEmpty()` declaration that has
+ * expired — ADR-010 part 3: the number IS the finding, so it is named.
+ */
+export function expiredExpectEmptyViolation(facts, examined) {
+    const message = `this rule declared .expectEmpty() but examined ${String(examined)} unit(s) — the ` +
+        `declaration has expired. If the corpus legitimately grew past empty, remove ` +
+        `.expectEmpty() from this rule; the underlying violations (if any) above still stand.`;
+    return configFinding(facts, message);
+}
+//# sourceMappingURL=vacuity-findings.js.map

package/dist/vacuity-findings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vacuity-findings.js","sourceRoot":"","sources":["../src/vacuity-findings.ts"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH;;;;;;;;;;;;;;GAcG;AACH,SAAS,aAAa,CAAC,KAAgB,EAAE,OAAe;IACtD,MAAM,SAAS,GAAG,KAAK,CAAC,YAAY,EAAE,CAAA;IACtC,MAAM,IAAI,GAAG,SAAS,CAAC,EAAE,IAAI,SAAS,CAAC,IAAI,IAAI,KAAK,CAAC,SAAS,CAAC,IAAI,CAAA;IACnE,OAAO;QACL,IAAI,EAAE,SAAS,CAAC,IAAI,IAAI,IAAI;QAC5B,MAAM,EAAE,SAAS,CAAC,EAAE;QACpB,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,EAAE;QACR,IAAI,EAAE,CAAC;QACP,OAAO;QACP,UAAU,EAAE,OAAO;QACnB,OAAO,EAAE,KAAK,CAAC,MAAM;QACrB,aAAa,EAAE,IAAI;KACpB,CAAA;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,KAAgB;IACpD,MAAM,OAAO,GACX,iFAAiF;QACjF,oFAAoF;QACpF,kFAAkF;QAClF,4EAA4E,CAAA;IAC9E,OAAO,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;AACtC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAgB,EAAE,QAAgB;IAClE,MAAM,OAAO,GAAG,mCAAmC,QAAQ,EAAE,CAAA;IAC7D,OAAO,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;AACtC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,4BAA4B,CAAC,KAAgB;IAC3D,MAAM,OAAO,GACX,iFAAiF;QACjF,oFAAoF;QACpF,mFAAmF;QACnF,kCAAkC,CAAA;IACpC,OAAO,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;AACtC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAAgB;IACxD,MAAM,OAAO,GACX,oFAAoF;QACpF,4EAA4E;QAC5E,+EAA+E;QAC/E,6CAA6C,CAAA;IAC/C,OAAO,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;AACtC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,2BAA2B,CAAC,KAAgB,EAAE,QAAgB;IAC5E,MAAM,OAAO,GACX,kDAAkD,MAAM,CAAC,QAAQ,CAAC,iBAAiB;QACnF,8EAA8E;QAC9E,sFAAsF,CAAA;IACxF,OAAO,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;AACtC,CAAC"}

package/dist/violation.d.ts

@@ -1,10 +1,7 @@
 /**
  * A single architecture rule violation.
  *
- * Represents one element that failed to satisfy a condition. This is the
- * kernel's central data type — dialect-independent. Each dialect provides its
- * own adapter that builds an `ArchViolation` from that dialect's element type
- * (e.g. the TS dialect builds one from a ts-morph `Node`).
+ * Represents one element that failed to satisfy a condition.
  */
 /**
  * A deterministic, unique text edit that repairs a violation (plan 0066). Emitted
@@ -35,8 +32,79 @@ export interface ArchViolation {
     file: string;
     /** Line number where the violating element starts */
     line: number;
+    /**
+     * Other files this one finding concerns, when it concerns more than one.
+     *
+     * A finding carries a single `file`, which is where it is REPORTED. Some
+     * findings are about a relationship — two bodies that duplicate each other,
+     * a cluster of them — and for those, one path cannot say what the finding is
+     * about. Anything that filters by file must see the rest, or it hides the
+     * finding from the very person who caused it.
+     *
+     * Bug 0239 is the measured case: a duplicate-body finding anchors on whichever
+     * member the source walk reached first, so a developer who pasted a body into
+     * a second file ran `--changed` and was told nothing — the finding sat on the
+     * file they had not touched, and which file that was came down to how the OS
+     * enumerated a directory.
+     *
+     * Optional, and additive. A single-file finding omits it and every existing
+     * producer keeps compiling; a consumer that ignores it behaves exactly as
+     * before. `file` remains where the finding is reported, so messages, editors
+     * and baselines are unaffected.
+     */
+    relatedFiles?: readonly string[];
     /** Human-readable description of what went wrong */
     message: string;
+    /**
+     * Stable identity for baseline matching, when the rendered message is not a
+     * safe identifier.
+     *
+     * By default a violation is identified by `rule::element::message`, which is
+     * right as long as the message says only what is wrong. It breaks when the
+     * message also encodes *circumstances*:
+     *
+     * - a derived population — `"3 of 5 files … use X"` becomes `"4 of 6"` when
+     *   an unrelated sibling is added, and every accepted finding in that folder
+     *   changes identity;
+     * - an ordering — a pairwise detector that reports `A → B` reports `B → A`
+     *   when the file walk runs in a different order, which is a property of the
+     *   filesystem, not of the code;
+     * - a coordinate — `"at line 12"` moves when anything above it is edited.
+     *
+     * Set this to a canonical form and identity survives all three. It replaces
+     * both `element` and `message` in the hash, so it must be unique per finding
+     * within a rule: two distinct violations sharing one identity are one
+     * violation to the baseline, and accepting either accepts both. Absolute
+     * paths inside it are fine — they are normalised away with the rest
+     * (`src/core/identity-root.ts`).
+     *
+     * The rendered output is unaffected; this is identity only.
+     */
+    identity?: string;
+    /**
+     * The measurement this finding reports, for a metric condition — bug 0012.
+     *
+     * The baseline stores it and compares rather than equates, so improving a
+     * metric stays green while regressing past the accepted value fails. Absent
+     * on every non-metric finding, where equality of identity is the right test.
+     */
+    measured?: number;
+    /**
+     * What {@link measured} counts — `code-lines`, `methods`, `complexity`.
+     *
+     * The baseline persists it and refuses to compare a stored measurement
+     * against a current one carrying a different unit
+     * ([bug 0171](../../../work/bugs/fixed/0171-a-metric-unit-change-silently-loosens-every-baselined-ratchet.md)).
+     * Without it, changing what a metric COUNTS silently moved every baselined
+     * ceiling: `linesOfCode` went from span lines to code lines, entries kept
+     * matching on identity, and a class could then grow to roughly three times
+     * its accepted size while the build stayed green.
+     *
+     * Absent on findings from a producer that predates this, which the baseline
+     * treats as "unit unknown" — comparable only for the metrics whose meaning
+     * has never changed.
+     */
+    measuredUnit?: string;
     /** Optional rationale provided via .because() */
     because?: string;
     /** Source code snippet around the violation line */
@@ -47,5 +115,106 @@ export interface ArchViolation {
     docs?: string;
     /** A deterministic, unique text edit that repairs this violation (plan 0066). */
     fix?: ArchFix;
+    /** Severity of this violation. Absent means 'error' (the default). */
+    severity?: 'error' | 'warn';
+    /**
+     * When true, this is a meta-finding about rule *configuration* (e.g. an empty
+     * selector or empty discovery), not about a source file. It has no changed
+     * file to attribute to, so the diff-aware and baseline filters must NOT drop
+     * it — otherwise the guard silently re-greens under the standard CI mode
+     * (ADR-008; plan 0067).
+     */
+    bypassFilters?: boolean;
 }
+/**
+ * Extract a human-readable name from a ts-morph Node.
+ *
+ * If the node itself is a named declaration (class, function, method, etc.),
+ * returns its name directly. Otherwise, walks up the AST ancestors to find
+ * the nearest named declaration and builds a qualified name like
+ * "ClassName.methodName". This ensures that inner nodes (e.g., AsExpression,
+ * CallExpression) produce meaningful element names for `.excluding()` matching.
+ *
+ * Falls back to the node's kind name only if no named ancestor is found
+ * (e.g., top-level expressions in a module).
+ */
+/**
+ * Force a configuration meta-finding to `error`, whatever the rule asked for.
+ *
+ * A `bypassFilters` finding reports that the rule enforces **nothing**. That is
+ * not a violation the author gets to grade: `.asSeverity('warn')` says "these
+ * violations are advisory", and a rule that cannot fire has no violations to
+ * be advisory about. Under ADR-009 rule 1 an actionable finding must fail, and
+ * the other suppression paths already refuse to silence these — `.excluding()`
+ * refuses explicitly, baseline and diff honour the flag. The full roster is
+ * `UNSUPPRESSABLE_MECHANISMS` in `unsuppressable.ts`, which is also what the
+ * user-facing sentence is built from; it has grown twice, so it is named here
+ * rather than counted. (This paragraph said "three of the four" while the list
+ * stood at six.)
+ *
+ * Applied at all three severity-stamping sites. `stampSeverity` alone is not
+ * enough: `.violations()` inlines its own map in both root builders, and the
+ * `executeWarn` path resolves an unset severity to `warn`, which is where most
+ * producers landed.
+ */
+export declare function severityFor(violation: ArchViolation, fallback: 'error' | 'warn'): 'error' | 'warn';
+/**
+ * True when a violation's remedy **is** its message, so a renderer that has
+ * already shown the message must not append a `Fix:` line repeating it.
+ *
+ * The assertion gate's finding reports that a rule cannot fire; there, the fault
+ * and its remedy are one sentence, and both fields carry that sentence on
+ * purpose — the JSON payload reads `suggestion`, a human reads the body, and a
+ * configuration finding is the one kind that cannot fall back to the author's
+ * `suggestion` (`execute-rule.ts` refuses it, bug 0021). Measured before the
+ * fix: every surface printed the same paragraph twice.
+ *
+ * One definition, because the three renderers must not disagree about it.
+ * Whether a given renderer *did* render the message stays renderer-local: the
+ * rich terminal format shows it only for a location-less finding, while the
+ * plain and GitHub formats always do.
+ */
+export declare function remedyRepeatsMessage(violation: ArchViolation): boolean;
+/**
+ * Unicode codepoint order — the only comparator admissible anywhere a baseline identity, an
+ * `element`, or a reported location is derived from a sort.
+ *
+ * `String.prototype.localeCompare` without an explicit locale reads the **host** locale from
+ * `LANG`/`LC_ALL`, so a value sorted with it differs between a developer's machine and CI.
+ * Measured on plain ASCII: `['zebra','aardvark']` sorts to `aardvark,zebra` under `en-US` and
+ * to `zebra,aardvark` under `da-DK`, because Danish collates `aa` as `å`, after `z`. One
+ * finding, two baseline hashes, diverging only in the place hardest to debug.
+ *
+ * The codebase already knew: `module-edges.ts` wrote *"`localeCompare` is ICU/locale sensitive
+ * — exactly the machine-dependent ordering `conditions/slice.ts` goes out of its way to
+ * eliminate, because a value that differs per machine gives one finding two identities"* — 60
+ * lines above a `localeCompare` in the identity discriminator, while `conditions/slice.ts`
+ * eliminated its own machine-dependence *using `localeCompare`*. Four sites in all.
+ *
+ * `tests/tools/scan-locale-ordering.test.ts` is what keeps that from recurring: a runtime row
+ * cannot catch it, because on an `en-US` machine both comparators agree — a guard written for
+ * this defect passed 16/16 with the defect reinstated.
+ */
+export declare function byCodepoint(a: string, b: string): number;
+/**
+ * The subject `hashViolation` keys a baseline entry on: `identity`, or `element::message`.
+ *
+ * **Exported and consumed by `hashViolation`/`hashSubject`** rather than duplicated. An earlier
+ * draft kept a private copy here on the reasoning that `core/` must not depend on `helpers/` —
+ * true, but backwards: `helpers/baseline.ts` already imports from `core/`, which is the
+ * permitted direction, and `core/identity-root.ts` records the same move for the same reason.
+ * A copy plus a test asserting the copies agree is strictly worse than one definition: the
+ * test can only compare the formulas over fixtures it happens to build, and the first draft's
+ * fixture shared every field, so it agreed under any formula.
+ */
+export declare function subjectOf(violation: ArchViolation): string;
+/** Every subject a rule produced more than once, since the last reset. */
+export declare function identityCollisions(): readonly {
+    rule: string;
+    subject: string;
+    findings: number;
+}[];
+/** Clear the record — call in a `beforeEach` when asserting on a specific rule. */
+export declare function resetIdentityCollisions(): void;
+export declare function disambiguateIdentities(violations: ArchViolation[]): ArchViolation[];
 //# sourceMappingURL=violation.d.ts.map

package/dist/violation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"violation.d.ts","sourceRoot":"","sources":["../src/violation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAA;IACX,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAA;IACnB,sFAAsF;IACtF,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAA;IACf,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAA;IACf,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0GAA0G;IAC1G,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,iFAAiF;IACjF,GAAG,CAAC,EAAE,OAAO,CAAA;CACd"}
+{"version":3,"file":"violation.d.ts","sourceRoot":"","sources":["../src/violation.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAA;IACX,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAA;IACnB,sFAAsF;IACtF,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAA;IACf,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAA;IACZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAA;IACf;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0GAA0G;IAC1G,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,iFAAiF;IACjF,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,sEAAsE;IACtE,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAC3B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;;;;;;GAWG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,OAAO,GAAG,MAAM,GACzB,OAAO,GAAG,MAAM,CAElB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAEtE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM,CAE1D;AA0GD,0EAA0E;AAC1E,wBAAgB,kBAAkB,IAAI,SAAS;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;CACjB,EAAE,CAEF;AAED,mFAAmF;AACnF,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAID,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CA6DnF"}