@nielspeter/eess 0.2.1 → 0.4.0

package/dist/vacuity-findings.d.ts

@@ -0,0 +1,55 @@
+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;
+}
+/**
+ * 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.
+ */
+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;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAmBrE;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAenF;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAmB5E;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAmBzE;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAkB7F"}

package/dist/vacuity-findings.js

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ */
+export function zeroExaminedViolation(facts) {
+    const described = facts.describeRule();
+    const name = described.id ?? described.rule ?? facts.ruleClass.name;
+    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 {
+        rule: described.rule ?? name,
+        ruleId: described.id,
+        element: name,
+        file: '',
+        line: 0,
+        message,
+        suggestion: message,
+        because: facts.reason,
+        bypassFilters: true,
+    };
+}
+/**
+ * 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 described = facts.describeRule();
+    const name = described.id ?? described.rule ?? facts.ruleClass.name;
+    const message = `this rule examined zero units — ${deadGlob}`;
+    return {
+        rule: described.rule ?? name,
+        ruleId: described.id,
+        element: name,
+        file: '',
+        line: 0,
+        message,
+        suggestion: message,
+        because: facts.reason,
+        bypassFilters: true,
+    };
+}
+/**
+ * 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 described = facts.describeRule();
+    const name = described.id ?? described.rule ?? facts.ruleClass.name;
+    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 {
+        rule: described.rule ?? name,
+        ruleId: described.id,
+        element: name,
+        file: '',
+        line: 0,
+        message,
+        suggestion: message,
+        because: facts.reason,
+        bypassFilters: true,
+    };
+}
+/**
+ * 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 described = facts.describeRule();
+    const name = described.id ?? described.rule ?? facts.ruleClass.name;
+    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 {
+        rule: described.rule ?? name,
+        ruleId: described.id,
+        element: name,
+        file: '',
+        line: 0,
+        message,
+        suggestion: message,
+        because: facts.reason,
+        bypassFilters: true,
+    };
+}
+/**
+ * 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 described = facts.describeRule();
+    const name = described.id ?? described.rule ?? facts.ruleClass.name;
+    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 {
+        rule: described.rule ?? name,
+        ruleId: described.id,
+        element: name,
+        file: '',
+        line: 0,
+        message,
+        suggestion: message,
+        because: facts.reason,
+        bypassFilters: true,
+    };
+}
+//# 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":"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"}

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
@@ -37,6 +34,56 @@ export interface ArchViolation {
     line: number;
     /** 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/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 +94,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,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"}

package/dist/violation.js

@@ -1,2 +1,263 @@
-export {};
+import { registerCacheReset } from './cache-registry.js';
+/**
+ * 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 function severityFor(violation, fallback) {
+    return violation.bypassFilters === true ? 'error' : fallback;
+}
+/**
+ * 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 function remedyRepeatsMessage(violation) {
+    return violation.suggestion !== undefined && violation.suggestion === violation.message;
+}
+/**
+ * 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 function byCodepoint(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * 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 function subjectOf(violation) {
+    return violation.identity ?? `${violation.element}::${violation.message}`;
+}
+/**
+ * The full key `hashViolation` hashes — `rule::subject` — and therefore the unit
+ * {@link disambiguateIdentities} must group on.
+ *
+ * **Grouping on the subject alone was a defect**, measured: `hashViolation` includes `rule`, so
+ * two findings carrying the same `element::message` under *different* rule descriptions already
+ * hash apart and were never ambiguous. Suffixing the second moved a baseline entry that had no
+ * collision — the precise failure this mechanism exists to avoid, committed by the mechanism.
+ *
+ * Not live at the time it was found (instrumenting the whole suite showed one batch carrying
+ * more than one rule string and zero over-suffixed findings), but reachable by construction:
+ * several builders mix `metadata?.id ?? description` with a bare `description` inside one batch
+ * — `slice-rule-builder.ts`, `correspondence-builder.ts`, `tsconfig-builder.ts`,
+ * `inconsistent-siblings.ts`, `schema-rule-builder.ts` all do. Any of them emitting a colliding
+ * subject across their two rule strings would have moved a published entry.
+ */
+function groupKeyOf(violation) {
+    return `${violation.rule}::${subjectOf(violation)}`;
+}
+/**
+ * Give every finding in a rule a distinct identity, by suffixing only the ones that collide.
+ *
+ * {@link ArchViolation.identity} states the invariant this enforces: *"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."* That was prose with nothing behind it, and
+ * three families broke it independently —
+ * [ts-archunit bug 0063](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0063-a-dependency-identity-collides-across-files-sharing-a-basename.md)
+ * (dependency), [ts-archunit plan 0088](https://github.com/nielspeter/ts-archunit/blob/main/plans/0088-a-slice-finding-identifies-itself.md) (slice), and
+ * then [0064](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0064-a-dependency-identity-collides-across-two-spellings-of-one-module.md)
+ * and [0065](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0065-reverse-dependency-findings-carry-no-identity.md). Each was fixed
+ * per-family, in the family that happened to be reviewed; this is the mechanism, so the next
+ * producer cannot reintroduce it.
+ *
+ * **A finding whose subject is unique is returned untouched — that is a theorem, not a
+ * measurement.** Only a subject that appears more than once is altered, and only from its
+ * second occurrence onward, so:
+ *
+ * - no existing baseline entry moves, because a *unique* entry is what a correct baseline holds;
+ * - the entry a colliding pair *did* record still matches, because the first occurrence keeps
+ *   its subject verbatim — so the fail-open closes by making the hidden sibling report as new,
+ *   which is the finding an adopter never got to see.
+ *
+ * Groups that collide were, by definition, one baseline entry standing for two findings: an
+ * entry that was already wrong. Those are the only ones that move.
+ *
+ * **Ordering — a limitation, not a guarantee.** The suffix follows the order the rule produced
+ * its findings, so a baseline entry accepts *a position in a group*, not *a finding*. An earlier
+ * draft of this paragraph said the residual "is not a fail-open, because the group still yields
+ * as many distinct identities as it has findings", and cited `ModuleEdge.ordinal` as its source.
+ * The premise is true and the conclusion does not follow — and that source, which measured the
+ * identical residual one layer down, concludes the opposite. Its table, reproduced because it
+ * applies verbatim here:
+ *
+ * | edit to an accepted colliding group       | new reds reported |
+ * | ----------------------------------------- | ----------------- |
+ * | add a sibling                             | 1 — correct       |
+ * | insert a sibling **above** the first        | 1 — correct count |
+ * | **delete one, add a different one**       | **0 — silent**    |
+ *
+ * So the equal-count swap is a **fail-open**: a violation that did not exist when the baseline
+ * was written arrives pre-accepted. Strictly better than before this mechanism — where *any*
+ * number of added siblings was pre-accepted, not only an equal-count swap — and still a hole.
+ *
+ * The middle row is right about the number and wrong about the name: the finding reported may
+ * be a **sibling nobody touched**, while the newly-added one takes the bare subject and matches
+ * the existing entry. For ADR-008's stated primary consumer — an agent that acts on the message
+ * — pointing at the wrong file is worse than a miss.
+ *
+ * Sharper still where an entry carries state: a `measured` metric entry holds an accepted
+ * ceiling, so a swap can hand the survivor a ceiling belonging to a different element and
+ * silently accept a regression. That is bug 0028's shape recreated inside bug 0012's fix.
+ *
+ * The durable answer is a real per-finding identity — a `binding` field for the edge family,
+ * qualified names for the metric family — tracked in
+ * [ts-archunit plan 0094](https://github.com/nielspeter/ts-archunit/blob/main/plans/0094-the-residual-findings-from-the-v0-56-0-review.md). This is the
+ * floor: a collision can no longer be silent *at scale*. It is not the ceiling.
+ *
+ * **Why here and not per condition.** `applyFilters` is the one path every terminal shares, and
+ * its own contract is that identity is complete before any filter reads it. Running before the
+ * filters also makes identity a property of *what the rule found* rather than of what a
+ * `--changed` or `.excluding()` run happened to keep — the same identity in CI and locally.
+ */
+/**
+ * Subjects the mechanism had to disambiguate, by rule — the producer-quality signal.
+ *
+ * **Why this exists.** `disambiguateIdentities` guarantees that a rule's findings have distinct
+ * identities, which silently turned every `new Set(hashes).size === findings.length` assertion
+ * in the suite into a tautology. Measured: collapsing `duplicate-bodies.ts`'s identity to a
+ * literal constant — the worst producer defect available — left **all 234 files and 3178 tests
+ * green**, including `baseline-portability.test.ts`, whose own comment says *"collision is the
+ * failure mode this primitive introduces, so it gets its own guard."*
+ *
+ * The mechanism is a safety net, not a licence for producers to stop identifying their
+ * findings: a positional suffix makes an entry a *slot*, while a producer identity makes it a
+ * *reference*, and only the latter survives a sibling being deleted (see the ordering table
+ * above). So the guards must keep measuring the producer, and after this mechanism the only
+ * way to do that is to ask what the mechanism had to repair.
+ *
+ * Same shape as `recordEdgeCoverage`/`untestedRules` next door, for the same reason: a
+ * disclosure channel that a test can assert on without the production path knowing it exists.
+ */
+const collisions = [];
+/** Every subject a rule produced more than once, since the last reset. */
+export function identityCollisions() {
+    return collisions;
+}
+/** Clear the record — call in a `beforeEach` when asserting on a specific rule. */
+export function resetIdentityCollisions() {
+    collisions.length = 0;
+}
+registerCacheReset(resetIdentityCollisions);
+export function disambiguateIdentities(violations) {
+    const counts = new Map();
+    for (const violation of violations) {
+        const key = groupKeyOf(violation);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    // Nothing collides: return the input untouched rather than rebuilding it, so the
+    // overwhelmingly common case costs one pass and no allocation.
+    let anyDuplicate = false;
+    for (const count of counts.values()) {
+        if (count > 1) {
+            anyDuplicate = true;
+            break;
+        }
+    }
+    if (!anyDuplicate)
+        return violations;
+    // Disclose what had to be repaired, so a guard can still measure the PRODUCER — see
+    // `identityCollisions`. Recorded before the repair, because afterwards there is nothing left
+    // to see, which is precisely how this mechanism disarmed the existing collision guards.
+    for (const [key, count] of counts) {
+        if (count > 1) {
+            const split = key.indexOf('::');
+            collisions.push({
+                rule: key.slice(0, split),
+                subject: key.slice(split + 2),
+                findings: count,
+            });
+        }
+    }
+    // Every key present before suffixing, so a generated `#n` can never land on one a producer
+    // already emits. Without it, a rule holding `X` twice plus a literal `X#1` closes one
+    // collision by opening another — and `taken.add` below is what keeps that true for the
+    // THIRD member: without it, `[X, X, X, X#1]` yields `X, X#2, X#2, X#1`, reintroducing the
+    // collision this function exists to remove. Measured; it takes a group of three to reach,
+    // which is why the guard for it carries three.
+    const taken = new Set(counts.keys());
+    const seen = new Map();
+    return violations.map((violation) => {
+        const key = groupKeyOf(violation);
+        if ((counts.get(key) ?? 0) < 2)
+            return violation;
+        const occurrence = (seen.get(key) ?? 0) + 1;
+        seen.set(key, occurrence);
+        // The first keeps its subject verbatim — this is what makes the migration empty.
+        if (occurrence === 1)
+            return violation;
+        // The suffix goes on the SUBJECT, because that is what `identity` is; the reservation is
+        // checked on the group key, because that is what collides.
+        const subject = subjectOf(violation);
+        let suffix = occurrence - 1;
+        let candidate = `${subject}#${String(suffix)}`;
+        while (taken.has(`${violation.rule}::${candidate}`)) {
+            suffix += 1;
+            candidate = `${subject}#${String(suffix)}`;
+        }
+        taken.add(`${violation.rule}::${candidate}`);
+        return { ...violation, identity: candidate };
+    });
+}
 //# sourceMappingURL=violation.js.map

package/dist/violation.js.map

@@ -1 +1 @@
-{"version":3,"file":"violation.js","sourceRoot":"","sources":["../src/violation.ts"],"names":[],"mappings":""}
+{"version":3,"file":"violation.js","sourceRoot":"","sources":["../src/violation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAgHxD;;;;;;;;;;;GAWG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,WAAW,CACzB,SAAwB,EACxB,QAA0B;IAE1B,OAAO,SAAS,CAAC,aAAa,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAA;AAC9D,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,oBAAoB,CAAC,SAAwB;IAC3D,OAAO,SAAS,CAAC,UAAU,KAAK,SAAS,IAAI,SAAS,CAAC,UAAU,KAAK,SAAS,CAAC,OAAO,CAAA;AACzF,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,WAAW,CAAC,CAAS,EAAE,CAAS;IAC9C,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACnC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,SAAS,CAAC,SAAwB;IAChD,OAAO,SAAS,CAAC,QAAQ,IAAI,GAAG,SAAS,CAAC,OAAO,KAAK,SAAS,CAAC,OAAO,EAAE,CAAA;AAC3E,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAS,UAAU,CAAC,SAAwB;IAC1C,OAAO,GAAG,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,SAAS,CAAC,EAAE,CAAA;AACrD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,GAA0D,EAAE,CAAA;AAE5E,0EAA0E;AAC1E,MAAM,UAAU,kBAAkB;IAKhC,OAAO,UAAU,CAAA;AACnB,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,uBAAuB;IACrC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAA;AACvB,CAAC;AAED,kBAAkB,CAAC,uBAAuB,CAAC,CAAA;AAE3C,MAAM,UAAU,sBAAsB,CAAC,UAA2B;IAChE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAA;IACxC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,MAAM,GAAG,GAAG,UAAU,CAAC,SAAS,CAAC,CAAA;QACjC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;IAC7C,CAAC;IACD,iFAAiF;IACjF,+DAA+D;IAC/D,IAAI,YAAY,GAAG,KAAK,CAAA;IACxB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QACpC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,YAAY,GAAG,IAAI,CAAA;YACnB,MAAK;QACP,CAAC;IACH,CAAC;IACD,IAAI,CAAC,YAAY;QAAE,OAAO,UAAU,CAAA;IAEpC,oFAAoF;IACpF,6FAA6F;IAC7F,wFAAwF;IACxF,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;QAClC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YAC/B,UAAU,CAAC,IAAI,CAAC;gBACd,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC;gBACzB,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC;gBAC7B,QAAQ,EAAE,KAAK;aAChB,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IAED,2FAA2F;IAC3F,sFAAsF;IACtF,uFAAuF;IACvF,0FAA0F;IAC1F,0FAA0F;IAC1F,+CAA+C;IAC/C,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAA;IACpC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAA;IAEtC,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE;QAClC,MAAM,GAAG,GAAG,UAAU,CAAC,SAAS,CAAC,CAAA;QACjC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;YAAE,OAAO,SAAS,CAAA;QAEhD,MAAM,UAAU,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;QAC3C,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAAA;QACzB,iFAAiF;QACjF,IAAI,UAAU,KAAK,CAAC;YAAE,OAAO,SAAS,CAAA;QAEtC,yFAAyF;QACzF,2DAA2D;QAC3D,MAAM,OAAO,GAAG,SAAS,CAAC,SAAS,CAAC,CAAA;QACpC,IAAI,MAAM,GAAG,UAAU,GAAG,CAAC,CAAA;QAC3B,IAAI,SAAS,GAAG,GAAG,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,CAAA;QAC9C,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC,EAAE,CAAC;YACpD,MAAM,IAAI,CAAC,CAAA;YACX,SAAS,GAAG,GAAG,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,CAAA;QAC5C,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC,CAAA;QAC5C,OAAO,EAAE,GAAG,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAA;IAC9C,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nielspeter/eess",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "eess kernel — the dialect-independent rule engine (RuleBuilder, Predicate, Condition, baseline, formatters). Specifications you can run.",
   "type": "module",
   "exports": {