@nielspeter/eess 0.2.2 → 0.5.0

package/dist/report.js

@@ -1,3 +1,5 @@
+import { collectResult, hasEvidence } from './collect-result.js';
+import { isEmitterFinding, noReceiptViolation, sourceEmptyViolation, passWithoutEvidenceViolation, expiredDeclarationViolation, contradictoryEvidenceViolation, } from './emitter-findings.js';
 import { ArchRuleError } from './errors.js';
 import { formatViolations } from './format.js';
 import { formatViolationsJson } from './format-json.js';
@@ -9,37 +11,211 @@ import { formatViolationsGitHub } from './format-github.js';
  * path) both delegate here, so the two reporting paths can no longer diverge
  * (plan 0070). Emits nothing for an empty set.
  */
+let violationsEmitted = 0;
+/**
+ * How many violations this module has actually WRITTEN, ever.
+ *
+ * Read as a delta by a caller that aggregates reporting, to answer one question it
+ * cannot otherwise answer: *did something emit while I was loading that module?*
+ *
+ * The alternative a caller might reach for — counting the writes it SUPPRESSED and
+ * inferring "then nothing was written" — is a double negative and is unsound: a
+ * module that suppresses one terminal and leaks through another satisfies it while
+ * leaking. Measured on `eess-ts`, which shipped that inference and fell into
+ * exactly that case. Count emissions, not silences.
+ */
+export function violationsEmittedCount() {
+    return violationsEmitted;
+}
+/**
+ * The evidence gate both emitters share — ADR-014 §1, §4.
+ *
+ * Produced BEFORE the delivery mode is chosen, so the finding is in the value
+ * returned under `return`, rides the throw under `throw`, and is in the text
+ * written under `warn`. A contract that binds only one door does not bind.
+ *
+ * A value that already carries a finding passes through untouched (§4): a
+ * terminal that examined nothing has already named its own cause, and "you
+ * constructed nothing" beside "your glob is dead" is a false second remedy.
+ */
+function withEvidenceGate(violations) {
+    // Deliberately looser than the exported signatures. The TYPE refuses a bare
+    // array (D1/D2); this guard is for the untyped JavaScript caller the type
+    // cannot reach — ADR-014's stated residual, and the field failure in
+    // proposal 009 was exactly that consumer.
+    if (!hasEvidence(violations)) {
+        return collectResult([...violations, noReceiptViolation()], { examined: 0 });
+    }
+    // Expiry FIRST, and before the `examined > 0` exit — ADR-014 §3. A declaration
+    // that cannot be contradicted is not an assertion, which is the whole reason
+    // §3's amendment refuses to infer one from a config. Checked even when real
+    // violations are present: the declaration is wrong independently of them.
+    if (violations.declaredEmpty === true && violations.examined > 0) {
+        return collectResult([...violations, expiredDeclarationViolation(violations.examined)], {
+            examined: violations.examined,
+            sourceEmpty: violations.sourceEmpty,
+        });
+    }
+    // The same check for the third state — ADR-014 §3, added after review found
+    // `notRun` shipped as a suppressor with no falsifier while `declaredEmpty` had
+    // one. A rule that never ran examined nothing and found nothing; either half
+    // present contradicts the flag, and BOTH are read because either alone would
+    // leave the other as an unchecked claim.
+    //
+    // Before the two exits below, deliberately: `examined > 0` is precisely the
+    // state that contradicts `notRun`, so checking after them would make the
+    // finding unreachable — the mistake this ADR's §2 warns about in its own
+    // implementation notes.
+    if (violations.notRun === true && (violations.examined > 0 || violations.length > 0)) {
+        return collectResult([...violations, contradictoryEvidenceViolation(violations.examined, violations.length)], { examined: violations.examined, sourceEmpty: violations.sourceEmpty });
+    }
+    // **`sourceEmpty` beside real evidence is a contradiction, like its siblings.**
+    // A source that loaded nothing cannot have yielded units to examine — the flag
+    // is set precisely when `examined === 0`. Checked before the two exits below,
+    // for the same reason the `notRun` check above is: after them it would be
+    // unreachable.
+    //
+    // Without this, `sourceEmpty` was the one flag in the vocabulary that could
+    // quiet a zero and never be contradicted — `notRun` beside evidence is
+    // `emitter/contradictory-evidence`, `declaredEmpty` beside evidence is
+    // `emitter/expired-declaration`, and `{ examined: 900, sourceEmpty: true }` was
+    // silent. That asymmetry is what ADR-014's "every flag that can quiet a zero
+    // can be contradicted" row exists to refuse, and promoting `sourceEmpty` to a
+    // verdict-changing flag with its own id is what put it in scope.
+    if (violations.sourceEmpty === true && violations.examined > 0) {
+        return collectResult([
+            ...violations,
+            contradictoryEvidenceViolation(violations.examined, violations.length, 'sourceEmpty'),
+        ], { examined: violations.examined });
+    }
+    if (violations.length > 0)
+        return violations;
+    if (violations.examined > 0)
+        return violations;
+    // **An empty source outranks any declaration, and names the source** — ADR-014
+    // §4, and ADR-010 §3's own `gated` row ("Zero loaded source files outranks any
+    // `.expectEmpty()` declaration") which the terminal has always honoured.
+    //
+    // This branch is checked BEFORE `declaredEmpty` and `notRun`, and that ordering
+    // is the whole point. The comment that used to sit here said `sourceEmpty` does
+    // not legitimise a zero — and the next line returned green on `declaredEmpty`
+    // without ever reading it. Measured:
+    // `finishPreset(collectResult([], { examined: 0, sourceEmpty: true, declaredEmpty: true }))`
+    // was GREEN. A hand-assembled receipt claiming an empty source and declaring it
+    // away is precisely the escape hatch that comment claimed this ADR had closed.
+    //
+    // A terminal that loaded nothing already carries `zeroLoadedSourceViolation` and
+    // exits at the `length > 0` line above, so this fires for the hand-assembled
+    // receipt — the population ADR-014's gate exists for.
+    if (violations.sourceEmpty === true) {
+        return collectResult([...violations, sourceEmptyViolation()], {
+            examined: violations.examined,
+            sourceEmpty: true,
+            // The input's own declarations are carried through, not dropped. They do
+            // not rescue the verdict — that is the precedence this branch enforces —
+            // but a downstream reader still needs to know they were made, and the
+            // sibling branches above preserve what they were handed for the same
+            // reason.
+            declaredEmpty: violations.declaredEmpty,
+            notRun: violations.notRun,
+            deadGlob: violations.deadGlob,
+        });
+    }
+    if (violations.declaredEmpty === true)
+        return violations;
+    // `notRun` legitimises a zero here for the same reason `declaredEmpty` does,
+    // and for the reason the MERGE already exempts it: a rule turned off examined
+    // nothing and found nothing, and reporting that as a vacuous pass is the
+    // "one disabled rule reddens a whole preset" failure `notRun` was added to
+    // prevent (measured on `adrEnforcement` with `adr/valid-tiers` off).
+    //
+    // **The two doors disagreed until this line.** `mergeCollectResults` exempts a
+    // `notRun` member from its dead filter; this gate had no such branch, so the
+    // per-builder doors judged an off rule alone and reddened it. Measured:
+    // `checkAll([healthy, off])` was GREEN while `eess-ts check` over the same two
+    // builders reported `1 of 2 rules failing`. Same receipts, opposite verdicts,
+    // decided by which door you walked through — and `check.ts` claimed per-builder
+    // gating was "strictly stronger, not weaker", which is how a false positive is
+    // manufactured.
+    //
+    // It is not a mute button: a `notRun` beside a non-zero `examined` or any
+    // violation is `emitter/contradictory-evidence`, checked above and reached
+    // before this line. And the all-off case still reports, because the merged
+    // receipt carries no `notRun` — so a preset whose every member is off sums to
+    // zero examined, undeclared, and reds exactly as ADR-014 §3 requires.
+    if (violations.notRun === true)
+        return violations;
+    return collectResult([passWithoutEvidenceViolation()], { examined: violations.examined });
+}
 export function reportViolations(violations, options = {}) {
-    if (violations.length === 0)
-        return;
+    const gated = withEvidenceGate(violations);
+    if (gated.length === 0)
+        return gated;
+    violationsEmitted += gated.length;
     const format = options.format ?? 'terminal';
     if (format === 'json') {
-        process.stdout.write(formatViolationsJson(violations, options.reason) + '\n');
+        process.stdout.write(formatViolationsJson(gated, options.reason) + '\n');
     }
     else if (format === 'github') {
-        process.stdout.write(formatViolationsGitHub(violations, 'error') + '\n');
+        process.stdout.write(formatViolationsGitHub(gated, 'error') + '\n');
     }
     else {
         // Rich text to stderr — test runners show the plain-text Error message,
         // while stderr carries the colorized Why/Fix/Docs output.
-        process.stderr.write(formatViolations(violations, options.reason) + '\n');
+        process.stderr.write(formatViolations(gated, options.reason) + '\n');
+    }
+    // ADR-014 §5: a bare `reportViolations` hands nothing back that a caller must
+    // act on, so a printed unsuppressable finding above a zero exit is the lie by
+    // another name. The gate's own finding escalates to a throw here.
+    if (gated.some((v) => v.bypassFilters === true && isEmitterFinding(v))) {
+        throw new ArchRuleError(gated, options.reason);
     }
+    return gated;
 }
 /**
  * Finish a preset: deliver its aggregated violations per the requested mode
- * (plan 0070). `throw` (default) emits then throws — backward-compatible with
- * `throwIfViolations`; `return` hands the violations back untouched (the caller
- * owns emission and control flow); `warn` emits without throwing. Always
- * returns the violations, so a caller can inspect them regardless of mode.
+ * (plan 0070). `throw` (default) emits then throws; `return` hands the
+ * violations back untouched (the caller owns emission and control flow);
+ * `warn` emits without throwing. Always returns the violations, so a caller can
+ * inspect them regardless of mode.
  */
 export function finishPreset(violations, options = {}) {
     const mode = options.report ?? 'throw';
+    // A caller's declaration reaches the gate ON the receipt (ADR-014 §3), never
+    // as a delivery option the gate reads separately — one boolean beside a sum
+    // cannot be weighed against that sum's parts.
+    const declared = options.expectEmpty === true && !violations.declaredEmpty
+        ? collectResult(violations, {
+            examined: violations.examined,
+            sourceEmpty: violations.sourceEmpty,
+            deadGlob: violations.deadGlob,
+            declaredEmpty: true,
+        })
+        : violations;
+    // The gate runs before the mode is read, so every door carries the finding.
+    const gated = withEvidenceGate(declared);
     if (mode === 'return')
-        return violations;
-    reportViolations(violations, options);
-    if (mode === 'throw' && violations.length > 0) {
-        throw new ArchRuleError(violations, options.reason);
+        return gated;
+    const emitterFinding = gated.some((v) => isEmitterFinding(v));
+    if (gated.length > 0) {
+        violationsEmitted += gated.length;
+        const format = options.format ?? 'terminal';
+        if (format === 'json') {
+            process.stdout.write(formatViolationsJson(gated, options.reason) + '\n');
+        }
+        else if (format === 'github') {
+            process.stdout.write(formatViolationsGitHub(gated, 'error') + '\n');
+        }
+        else {
+            process.stderr.write(formatViolations(gated, options.reason) + '\n');
+        }
+    }
+    // §5 again: `warn` prints without failing for ordinary violations, but an
+    // unsuppressable configuration finding printed above a zero exit is exactly
+    // the silent green this ADR closes.
+    if ((mode === 'throw' && gated.length > 0) || emitterFinding) {
+        throw new ArchRuleError(gated, options.reason);
     }
-    return violations;
+    return gated;
 }
 //# sourceMappingURL=report.js.map

package/dist/report.js.map

@@ -1 +1 @@
-{"version":3,"file":"report.js","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAwB3D;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAA2B,EAAE,UAAyB,EAAE;IACvF,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAM;IACnC,MAAM,MAAM,GAAiB,OAAO,CAAC,MAAM,IAAI,UAAU,CAAA;IACzD,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;QACtB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAA;IAC/E,CAAC;SAAM,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;IAC1E,CAAC;SAAM,CAAC;QACN,wEAAwE;QACxE,0DAA0D;QAC1D,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAA;IAC3E,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,UAA2B,EAC3B,UAA+B,EAAE;IAEjC,MAAM,IAAI,GAAe,OAAO,CAAC,MAAM,IAAI,OAAO,CAAA;IAClD,IAAI,IAAI,KAAK,QAAQ;QAAE,OAAO,UAAU,CAAA;IACxC,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;IACrC,IAAI,IAAI,KAAK,OAAO,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC9C,MAAM,IAAI,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACrD,CAAC;IACD,OAAO,UAAU,CAAA;AACnB,CAAC"}
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"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"}

package/dist/rule-builder-like.d.ts

@@ -0,0 +1,17 @@
+import type { CollectResult } from './collect-result.js';
+/**
+ * Minimal shape the CLI runner and presets collect violations from: anything
+ * exposing a non-throwing, severity-stamped `.violations()`. Lives in core (not
+ * `cli/`) so presets can return `RuleBuilderLike[]` without depending on CLI
+ * infrastructure.
+ *
+ * **The single member carries the evidence** — plan 0235's D1. An accessor
+ * beside it could be walked around: a caller keeps calling `violations()`,
+ * never asks for the count, and the evidence is optional again by another
+ * route. One member, and it hands back the receipt, so a rule file that cannot
+ * say what it examined does not compile.
+ */
+export interface RuleBuilderLike {
+    violations: () => CollectResult;
+}
+//# sourceMappingURL=rule-builder-like.d.ts.map

package/dist/rule-builder-like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-builder-like.d.ts","sourceRoot":"","sources":["../src/rule-builder-like.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,aAAa,CAAA;CAChC"}

package/dist/rule-builder-like.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rule-builder-like.js.map

package/dist/rule-builder-like.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-builder-like.js","sourceRoot":"","sources":["../src/rule-builder-like.ts"],"names":[],"mappings":""}

package/dist/rule-builder.d.ts

@@ -1,11 +1,24 @@
 import type { Predicate } from './predicate.js';
 import type { Condition, ConditionContext } from './condition.js';
-import type { ArchViolation } from './violation.js';
-import type { CheckOptions } from './check-options.js';
-import type { RuleMetadata } from './rule-metadata.js';
 import type { RuleDescription } from './rule-description.js';
-import type { SilentExclusion } from './silent-exclusion.js';
 import type { Selection, ElementInfo } from './correspondence.js';
+import type { GlobNode } from './glob-site.js';
+import { TerminalBuilder, type CollectResult } from './terminal-builder.js';
+/**
+ * The actual walk `RuleBuilder.globs()` delegates to — a free function
+ * rather than a method body, to keep the class itself under this repo's own
+ * 300-line class-length gate (`arch.internal.rules.ts`).
+ */
+/**
+ * The globs a rule declares, stamped with where each came from.
+ *
+ * Exported (as family plumbing) so `eess-ts` can call it instead of keeping its
+ * own copy — they were 94% similar, and the difference was not cosmetic: only
+ * the eess-ts copy honoured `originLabel`. The kernel's `Predicate` has carried
+ * that field all along and this function ignored it, so a preset's label was
+ * dropped for `eess-md`, `eess-mermaid` and `eess-gherkin`. Found by unifying.
+ */
+export declare function declaredGlobsOf<T>(predicates: readonly Predicate<T>[], conditions: readonly Condition<T>[]): GlobNode[];
 /**
  * Abstract base class for all rule builders.
  *
@@ -15,20 +28,35 @@ import type { Selection, ElementInfo } from './correspondence.js';
  * 3. Add condition methods that call `addCondition()`
  *
  * The builder accumulates predicates and conditions. Nothing executes
- * until a terminal method (`.check()`, `.warn()`, `.severity()`) is called.
+ * until a terminal method (`.check()`, `.warn()`, `.severity()`) is called —
+ * inherited from {@link TerminalBuilder} (plan 0088 Phase 4), which also
+ * supplies `because`/`rule`/`excluding`/`violations`/`expectEmpty`/
+ * `expectNonEmpty` and the ADR-010 evidence gate. `RuleBuilder` keeps its own
+ * `<T, P>` two-param generic — `P` is the dialect's project type, kept
+ * separate from `TerminalBuilder` (which has no project concept, since
+ * `correspondence()`, `SmellBuilder`, and the graphql builders don't share a
+ * uniform notion of "one project") — every builder across all five dialects
+ * depends on this exact two-param signature, so it is not replaced by the
+ * fold, only extended.
  */
-export declare abstract class RuleBuilder<T, P = unknown> {
+export declare abstract class RuleBuilder<T, P = unknown> extends TerminalBuilder {
     protected readonly project: P;
     protected _predicates: Predicate<T>[];
     protected _conditions: Condition<T>[];
-    protected _reason?: string;
-    protected _metadata?: RuleMetadata;
-    protected _exclusions: (string | RegExp)[];
-    protected _silentIndices: Set<number>;
     protected _phase: 'predicate' | 'condition';
+    /** Whether `.should()` was ever reached — bug 0155 state 3/4 vs state 1. */
+    protected _reachedShould: boolean;
+    /**
+     * Descriptions of predicate-only methods used AFTER `.should()` — bug 0155
+     * state 2. A dual-use method dispatches to a condition in that phase and
+     * never lands here, so anything recorded is genuinely a filter written where
+     * an assertion was meant.
+     */
+    protected _misplaced: string[];
     constructor(project: P);
     /**
-     * Begin the predicate phase. Returns `this` for chaining.
+     * Begin the predicate phase. Returns a COPY — a held selection is never
+     * edited by narrowing it (see `TerminalBuilder.copy()`).
      * Purely a readability marker — `.that().haveNameMatching(...)` reads like English.
      * Explicitly resets phase to 'predicate' — defensive against `.should().that()` misuse.
      */
@@ -59,50 +87,6 @@ export declare abstract class RuleBuilder<T, P = unknown> {
      * as a predicate; if it has `evaluate` it is treated as a condition.
      */
     satisfy(custom: Predicate<T> | Condition<T>): this;
-    /**
-     * Attach a human-readable rationale to the rule.
-     * Included in violation messages when `.check()` throws.
-     */
-    because(reason: string): this;
-    /**
-     * Attach rich metadata to the rule.
-     * Provides educational context in violation output: why, how to fix, docs link.
-     *
-     * If `metadata.because` is set, it also sets the reason (same as `.because()`).
-     */
-    rule(metadata: RuleMetadata): this;
-    /**
-     * Exclude specific violations from reporting by matching against
-     * the violation's `element`, `file`, or `message` fields.
-     *
-     * Matched violations are silently suppressed. Use for permanent,
-     * intentional exceptions — not for temporary violations (use baseline for those).
-     *
-     * Patterns are matched against all three fields. Prefer anchored regexes
-     * or full string matches over short substrings, especially for `message`
-     * matching, to avoid accidentally suppressing unrelated violations whose
-     * messages happen to contain the same text.
-     *
-     * Emits a warning if an exclusion matches zero violations — so renamed
-     * or deleted exceptions don't silently stay in the rule.
-     *
-     * For narrowing a rule's scope at the predicate phase (so the rule never
-     * evaluates the excluded element), use `satisfy(not(<predicate>))` instead.
-     * See the "Excluding a file from a rule's scope" recipe in docs/recipes.md.
-     *
-     * @example
-     * // Exclude by element name (fully qualified)
-     * .excluding('Asset.getImageUrl')
-     *
-     * @example
-     * // Exclude by file path (regex anchored to suffix)
-     * .excluding(/repositories\/index\.ts$/)
-     *
-     * @example
-     * // Multiple exclusions, mixed forms
-     * .excluding('Asset.getImageUrl', /\/legacy\//, /generated/)
-     */
-    excluding(...patterns: (string | RegExp | SilentExclusion)[]): this;
     /**
      * Return the predicate-filtered elements as a labelled `Selection<T>` for
      * cross-validation (`correspondence()`). The set is exactly the elements this
@@ -121,38 +105,61 @@ export declare abstract class RuleBuilder<T, P = unknown> {
      */
     describeRule(): RuleDescription;
     /**
-     * Execute the rule and return violations after exclusion filtering.
-     * Does not throw — use for programmatic access (presets, aggregation).
-     */
-    violations(): ArchViolation[];
-    /**
-     * Execute the rule and throw `ArchRuleError` if any violations are found.
-     * This is the primary terminal method — use in test assertions.
+     * ADR-010: is this rule's assertion satisfied by an empty selection, as a
+     * property of what its conditions assert (`.notExist()`) rather than a
+     * caller's `.expectEmpty()` declaration?
      *
-     * @param options - Optional baseline and diff filtering
-     */
-    check(options?: CheckOptions): void;
-    /**
-     * Execute the rule and log violations to stderr. Does not throw.
-     * Use for rules that should warn but not fail CI.
+     * `.every()`, not `.some()` — `.andShould()` ANDs, so a rule reading
+     * `.should().notExist().andShould().beExported()` still asserts something
+     * about subjects that exist, and exempting it on the strength of the one
+     * cardinality condition would silence the other. An empty condition list is
+     * NOT exempt: `[].every()` is vacuously `true`, and a rule with zero
+     * conditions is the assertion-less case `collectViolations()` now reports as
+     * a configuration finding (bug 0155; it used to be an unreachable stderr
+     * warning, which this comment named until that fix landed) — this override
+     * must not paper over it by also declaring it cardinality-satisfied.
      *
-     * @param options - Optional baseline and diff filtering
+     * **Load-bearing:** for a DEAD selector this early return is the only thing
+     * between an assertion-less rule and a silent pass (the gate runs after the
+     * zero-examined branch). Pinned in `assertion-less-rules.test.ts`.
      */
-    warn(options?: CheckOptions): void;
     /**
-     * Execute the rule with the given severity.
-     * `.severity('error')` is equivalent to `.check()`.
-     * `.severity('warn')` is equivalent to `.warn()`.
-     */
-    severity(level: 'error' | 'warn'): void;
+     * Does this rule assert anything at all? — bug 0155.
+     *
+     * Conditions alone are not enough: a predicate-only method written *after*
+     * `.should()` silently shrank the set the conditions run over, possibly to
+     * empty, in which case they hold vacuously. That rule asserts nothing
+     * meaningful even though `_conditions` is non-empty.
+     */
+    protected assertsSomething(): boolean;
+    protected assertionAdvice(): string;
+    protected assertsCardinality(): boolean;
+    /**
+     * ADR-010 part 3: did this rule's own underlying source (the project, a
+     * diagram, an SDL string — whatever `P` loads) produce nothing at all,
+     * before `getElements()`'s own domain-specific extraction or any
+     * predicate ran? Default `false` — the kernel has no way to know, since
+     * `P` is opaque here. A dialect's concrete builder, which knows `P`'s real
+     * shape (e.g. `ArchProject`), overrides this to check its own project's
+     * file count directly — never `getElements().length`, which conflates "the
+     * source is empty" with "this domain legitimately has nothing in a
+     * healthy project" (e.g. zero JSX elements in a backend-only codebase).
+     */
+    protected sourceEmpty(): boolean;
+    /** Declared globs, position derived from `_phase`. Pure — no `P` needed. */
+    globs(): readonly GlobNode[];
+    /** This rule's own project, for `diagnose()`/`doctor` outside `.check()`. */
+    getProject(): P;
+    /** A `globs()` tree diagnosably dead, when zero examined — same shape as `sourceEmpty()`. */
+    protected deadGlobDiagnosis(): string | undefined;
     /**
      * Register a predicate. Called by concrete builder methods like
-     * `.haveNameMatching()`, `.extend()`, etc.
+     * `.haveNameMatching()`, `.extend()`, etc. Returns a COPY — see `copy()`.
      */
     protected addPredicate(predicate: Predicate<T>): this;
     /**
      * Register a condition. Called by concrete builder methods like
-     * `.notContain()`, `.notExist()`, etc.
+     * `.notContain()`, `.notExist()`, etc. Returns a COPY — see `copy()`.
      */
     protected addCondition(condition: Condition<T>): this;
     /**
@@ -161,10 +168,31 @@ export declare abstract class RuleBuilder<T, P = unknown> {
      */
     protected abstract getElements(): T[];
     /**
-     * Create a fork of this builder with the same predicates but empty conditions.
-     * Used by `.should()` to support named selections without mutation.
+     * An independent copy, carrying **both** predicates and conditions.
+     * Extends `TerminalBuilder.copy()` with the fields this class adds.
+     *
+     * Subclasses with additional mutable-reference fields of their own (arrays,
+     * sets, maps a chain method pushes onto) MUST override this and call
+     * `super.copy()` first, the same reason `TerminalBuilder.copy()`'s own
+     * docstring gives — `Object.assign` shallow-copies a field, it does not
+     * give it independent identity.
+     */
+    protected copy(): this;
+    /**
+     * A fork of this builder, carrying BOTH lists. Used by `.should()` to support
+     * named selections without mutation.
+     *
+     * **Nothing here clears the conditions** (bug 0156). It used to, and a second
+     * `.should()` therefore silently discarded the first assertion — a rule that
+     * asserted something turned into one that asserted less, by a chain method.
+     * `.should().X().should().Y()` now accumulates exactly as `.andShould()` does.
      *
-     * Subclasses with additional constructor args MUST override this method.
+     * Ported from `packages/ts/src/core/rule-builder.ts`, where the engine copy
+     * landed the fix and left the kernel behind. Found by the architect review of
+     * PR #72: `eess-md`, `eess-mermaid` and `eess-gherkin` all extend THIS class,
+     * so they carried the defect — and `check:corpus`, `check:ledger` and
+     * `check:diagram` are md/mermaid gates, meaning this repo's own corpus
+     * enforcement ran on the broken copy.
      */
     protected fork(): this;
     /**
@@ -172,10 +200,22 @@ export declare abstract class RuleBuilder<T, P = unknown> {
      */
     private buildRuleDescription;
     /**
-     * Execute the full pipeline: filter elements with predicates,
-     * evaluate conditions, return violations.
-     */
-    private evaluate;
+     * Execute the full pipeline: filter elements with predicates, evaluate
+     * conditions, return violations plus the ADR-010 evidence — the
+     * post-predicate subject count, whatever it is. `TerminalBuilder.check()` /
+     * `.warn()` / `.violations()` decide what a zero count means (a
+     * configuration finding, unless `.expectEmpty()` was declared); this method
+     * only reports the count, never interprets it.
+     *
+     * `sourceEmpty` (ADR-010 part 3) is deliberately not `allElements.length
+     * === 0` — a domain's own `getElements()` legitimately returning nothing in
+     * a healthy, fully-loaded project (e.g. zero JSX elements in a
+     * backend-only codebase) is not brokenness, and conflating the two broke
+     * `.notExist()`'s cardinality exemption for exactly that case. Subclasses
+     * that can answer "did my underlying source load anything at all" override
+     * `sourceEmpty()`; the default assumes it did.
+     */
+    protected collectViolations(): CollectResult;
     /**
      * Build the `ConditionContext` passed to each condition.
      *

package/dist/rule-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-builder.d.ts","sourceRoot":"","sources":["../src/rule-builder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rule-builder.d.ts","sourceRoot":"","sources":["../src/rule-builder.ts"],"names":[],"mappings":"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"}