@nielspeter/eess 0.2.1 → 0.4.0

package/dist/define.js

@@ -12,9 +12,41 @@
  *
  * classes(p).that().satisfy(isAbstract).should().beExported().check()
  * ```
+ *
+ * ## Declaring a glob
+ *
+ * If the predicate matches paths against a glob, pass it as `globs` — otherwise
+ * `doctor` cannot see it, and a typo'd glob narrows the selection to nothing
+ * while reporting a clean bill of health. This is a **selector**-position glob,
+ * the one position that is acted on today, which is why the omission was bug
+ * 0030's higher-severity half.
+ *
+ * @example
+ * ```ts
+ * const inGeneratedFolder = definePredicate<SourceFile>(
+ *   "reside in '**\/generated/**'",
+ *   (file) => picomatch('**\/generated/**')(file.getFilePath()),
+ *   globNode({ glob: '**\/generated/**', kind: 'file-path' }),
+ * )
+ * ```
+ *
+ * The `kind` must say what the glob is really matched against, because it
+ * selects which paths the glob is checked for satisfiability:
+ *
+ * - `file-path` — an **absolute** file path. Anchor the glob (`'**\/src/**'`,
+ *   not `'src/**'`), or it matches nothing.
+ * - `parent-dir` — the immediate parent directory of a file.
+ * - `import-target` — a resolved module path **or a bare specifier**.
+ *   Deliberately has no path universe, so `'fastify'` is never reported dead.
+ * - `specifier` / `literal` — a string in the source rather than a path.
+ *
+ * A wrong `kind` is believed: declaring a bare specifier as `file-path` earns a
+ * false dead-glob report, and declaring a real path as `import-target` silently
+ * exempts it from checking. When unsure, the honest choice is to declare
+ * nothing — the same position as before this parameter existed.
  */
-export function definePredicate(description, test) {
-    return { description, test };
+export function definePredicate(description, test, globs) {
+    return { description, test, globs };
 }
 /**
  * Create a custom condition for use in `.should().satisfy()` chains.
@@ -35,8 +67,17 @@ export function definePredicate(description, test) {
  *
  * classes(p).that().extend('Base').should().satisfy(useSharedHelper).check()
  * ```
+ *
+ * ## Declaring a glob
+ *
+ * As with `definePredicate`, pass `globs` if the condition matches paths against
+ * one — see that function for the `kind` values and what a wrong one costs. The
+ * difference is what happens next: a **condition**-position glob is deliberately
+ * *not* reported when it matches nothing, because a denylist glob matching
+ * nothing is indistinguishable from a ban being respected. Declaring it makes it
+ * visible to `globs()` and `explain`; it does not make it a finding.
  */
-export function defineCondition(description, evaluate) {
-    return { description, evaluate };
+export function defineCondition(description, evaluate, globs) {
+    return { description, evaluate, globs };
 }
 //# sourceMappingURL=define.js.map

package/dist/define.js.map

@@ -1 +1 @@
-{"version":3,"file":"define.js","sourceRoot":"","sources":["../src/define.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe,CAC7B,WAAmB,EACnB,IAA6B;IAE7B,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,CAAA;AAC9B,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,eAAe,CAC7B,WAAmB,EACnB,QAAuE;IAEvE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAA;AAClC,CAAC"}
+{"version":3,"file":"define.js","sourceRoot":"","sources":["../src/define.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,UAAU,eAAe,CAC7B,WAAmB,EACnB,IAA6B,EAC7B,KAAqB;IAErB,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,CAAA;AACrC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,eAAe,CAC7B,WAAmB,EACnB,QAAuE,EACvE,KAAqB;IAErB,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAA;AACzC,CAAC"}

package/dist/diff-aware.d.ts

@@ -14,6 +14,14 @@ export declare class DiffFilter {
     /**
      * Filter violations to only those in changed files.
      * If changedFiles is null (git error), returns all violations unfiltered.
+     *
+     * A `bypassFilters` configuration finding (ADR-010's zero-examined /
+     * expired-`.expectEmpty()` violations) is never filtered here, even
+     * though its `file` is always `''` and can never be a member of
+     * `changedFiles`. Without this, "unsuppressable" was false for the most
+     * realistic adoption path: a rule whose instrument silently broke would
+     * report nothing at all under `--changed`, with no diagnostic that
+     * anything was ever hidden.
      */
     filterToChanged(violations: ArchViolation[]): ArchViolation[];
     /** Number of changed files detected, or -1 if diff unavailable */

package/dist/diff-aware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff-aware.d.ts","sourceRoot":"","sources":["../src/diff-aware.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD;;;;;;;;GAQG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;gBAErC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI;IAI5C;;;OAGG;IACH,eAAe,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE;IAM7D,kEAAkE;IAClE,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,UAAU,GAAE,MAAe,GAAG,UAAU,CA6BjE"}
+{"version":3,"file":"diff-aware.d.ts","sourceRoot":"","sources":["../src/diff-aware.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAGnD;;;;;;;;GAQG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;gBAErC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI;IAI5C;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE;IAM7D,kEAAkE;IAClE,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,UAAU,GAAE,MAAe,GAAG,UAAU,CA6BjE"}

package/dist/diff-aware.js

@@ -1,5 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import path from 'node:path';
+import { writeStderr } from './stderr.js';
 /**
  * A diff filter that restricts violation reporting to files
  * changed since a base branch.
@@ -17,12 +18,20 @@ export class DiffFilter {
     /**
      * Filter violations to only those in changed files.
      * If changedFiles is null (git error), returns all violations unfiltered.
+     *
+     * A `bypassFilters` configuration finding (ADR-010's zero-examined /
+     * expired-`.expectEmpty()` violations) is never filtered here, even
+     * though its `file` is always `''` and can never be a member of
+     * `changedFiles`. Without this, "unsuppressable" was false for the most
+     * realistic adoption path: a rule whose instrument silently broke would
+     * report nothing at all under `--changed`, with no diagnostic that
+     * anything was ever hidden.
      */
     filterToChanged(violations) {
         const files = this.changedFiles;
         if (files === null)
             return violations;
-        return violations.filter((v) => files.has(v.file));
+        return violations.filter((v) => v.bypassFilters === true || files.has(v.file));
     }
     /** Number of changed files detected, or -1 if diff unavailable */
     get size() {
@@ -56,7 +65,7 @@ export function diffAware(baseBranch = 'main') {
     catch (err) {
         // Not a git repo, or base branch doesn't exist — skip filtering (report all violations)
         const detail = err instanceof Error ? ` (${err.message.split('\n')[0] ?? ''})` : '';
-        console.warn(`[eess] Could not run git diff against '${baseBranch}'${detail}. All violations will be reported.`);
+        writeStderr(`[eess] Could not run git diff against '${baseBranch}'${detail}. All violations will be reported.`);
         return new DiffFilter(null);
     }
     if (output === '') {

package/dist/diff-aware.js.map

@@ -1 +1 @@
-{"version":3,"file":"diff-aware.js","sourceRoot":"","sources":["../src/diff-aware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,IAAI,MAAM,WAAW,CAAA;AAG5B;;;;;;;;GAQG;AACH,MAAM,OAAO,UAAU;IACJ,YAAY,CAAoB;IAEjD,YAAY,YAAgC;QAC1C,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;IAClC,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,UAA2B;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAA;QAC/B,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,UAAU,CAAA;QACrC,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;IACpD,CAAC;IAED,kEAAkE;IAClE,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAA;IACjE,CAAC;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CAAC,aAAqB,MAAM;IACnD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAA;IAEzB,IAAI,MAAc,CAAA;IAClB,IAAI,CAAC;QACH,MAAM,GAAG,YAAY,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,UAAU,SAAS,CAAC,EAAE;YAC5E,QAAQ,EAAE,OAAO;YACjB,GAAG;YACH,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;SAChC,CAAC,CAAC,IAAI,EAAE,CAAA;IACX,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wFAAwF;QACxF,MAAM,MAAM,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAA;QACnF,OAAO,CAAC,IAAI,CACV,0CAA0C,UAAU,IAAI,MAAM,oCAAoC,CACnG,CAAA;QACD,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,CAAA;IAC7B,CAAC;IAED,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;QAClB,wFAAwF;QACxF,OAAO,IAAI,UAAU,CAAC,IAAI,GAAG,EAAE,CAAC,CAAA;IAClC,CAAC;IAED,MAAM,YAAY,GAAG,IAAI,GAAG,CAC1B,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC,CAC1E,CAAA;IAED,OAAO,IAAI,UAAU,CAAC,YAAY,CAAC,CAAA;AACrC,CAAC"}
+{"version":3,"file":"diff-aware.js","sourceRoot":"","sources":["../src/diff-aware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,IAAI,MAAM,WAAW,CAAA;AAE5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEzC;;;;;;;;GAQG;AACH,MAAM,OAAO,UAAU;IACJ,YAAY,CAAoB;IAEjD,YAAY,YAAgC;QAC1C,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;IAClC,CAAC;IAED;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,UAA2B;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAA;QAC/B,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,UAAU,CAAA;QACrC,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,KAAK,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;IAChF,CAAC;IAED,kEAAkE;IAClE,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAA;IACjE,CAAC;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CAAC,aAAqB,MAAM;IACnD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAA;IAEzB,IAAI,MAAc,CAAA;IAClB,IAAI,CAAC;QACH,MAAM,GAAG,YAAY,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,UAAU,SAAS,CAAC,EAAE;YAC5E,QAAQ,EAAE,OAAO;YACjB,GAAG;YACH,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;SAChC,CAAC,CAAC,IAAI,EAAE,CAAA;IACX,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wFAAwF;QACxF,MAAM,MAAM,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAA;QACnF,WAAW,CACT,0CAA0C,UAAU,IAAI,MAAM,oCAAoC,CACnG,CAAA;QACD,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,CAAA;IAC7B,CAAC;IAED,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;QAClB,wFAAwF;QACxF,OAAO,IAAI,UAAU,CAAC,IAAI,GAAG,EAAE,CAAC,CAAA;IAClC,CAAC;IAED,MAAM,YAAY,GAAG,IAAI,GAAG,CAC1B,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC,CAC1E,CAAA;IAED,OAAO,IAAI,UAAU,CAAC,YAAY,CAAC,CAAA;AACrC,CAAC"}

package/dist/diff-disclosure.d.ts

@@ -0,0 +1,72 @@
+/**
+ * What diff-aware mode suppressed, said out loud.
+ *
+ * Plan 0071's first instrument. `--changed` (and `check({ diff })`) filter
+ * **reporting**, not evaluation — so a run with every finding suppressed is
+ * indistinguishable from a clean run: exit 0, no output, `total: 0`. That is
+ * the false green ADR-008 exists to prevent, and it is worse here than
+ * elsewhere because the reader chose the flag and then forgot it: CI configures
+ * `--changed` once and every subsequent run reads as clean.
+ *
+ * **The count is derived by the caller, never self-reported.** Each call site
+ * computes `before.length - after.length` around its own `filterToChanged`
+ * call. `DiffFilter` could keep that tally itself, and it deliberately does
+ * not: `CheckOptions.diff` is a structural interface (`DiffFilterLike`), so a
+ * consumer can pass any object with a `filterToChanged` method, and a filter
+ * that under-reports its own suppression would produce exactly the silence
+ * this module exists to break. Caller-side subtraction is a differently-derived
+ * value (ADR-009 rule 5) and it works for filters we did not write.
+ *
+ * **Two surfaces, because only one of them can count.**
+ *
+ * | surface                                  | disclosure           |
+ * | ---------------------------------------- | -------------------- |
+ * | CLI `check --changed`                    | `suppressionNotice`  |
+ * | `checkAll([...])`                        | `suppressionNotice`  |
+ * | `.check({ diff })` / `.warn({ diff })`   | `activeNotice`, once |
+ *
+ * The first two filter once over every collected violation, so they know the
+ * whole number. The per-rule terminals do not: `filterToChanged` is called
+ * once per rule (`execute-rule.ts`), and a diff-aware suite with 79 rules
+ * would print 79 lines — on the channel v0.26.0 made unconditionally visible.
+ * There is no per-run aggregation point on that path, so those terminals state
+ * the **configuration** instead, once per process. A configuration statement
+ * cannot be wrong; a per-rule count presented as a run total would be.
+ *
+ * A `process.on('exit')` flush was considered and rejected: it would let the
+ * per-rule path print one complete total, but a library that installs an exit
+ * hook to deliver a correctness-relevant message has made that message
+ * dependent on stderr surviving process teardown — untestable in the shape the
+ * rest of this project asserts (a real child `vitest run`, bug 0024) without
+ * asserting a race. Stating the configuration is weaker and honest.
+ */
+/**
+ * One line naming what was suppressed, or `undefined` when nothing was.
+ *
+ * `undefined` rather than an empty string so a call site cannot print a blank
+ * line by forgetting to check — the two callers both feed this straight into
+ * `writeStderr`.
+ *
+ * @param suppressed - `before.length - after.length`, computed by the caller.
+ * @param changedFiles - How many files the filter considered changed, when the
+ *   filter exposes it. A user-supplied `DiffFilterLike` need not, in which case
+ *   the sentence drops that clause rather than guessing.
+ * @param baseBranch - The branch diffed against, when known.
+ */
+export declare function suppressionNotice(suppressed: number, changedFiles?: number, baseBranch?: string): string | undefined;
+/**
+ * State that diff-aware filtering is on, once per process. Returns `undefined`
+ * on every call after the first, and whenever nothing was suppressed.
+ *
+ * Keyed on a call that actually suppressed something: a diff-aware run whose
+ * findings all happen to be in changed files has hidden nothing, and a notice
+ * there would train the reader to skip the line that matters.
+ */
+export declare function activeNotice(suppressed: number, changedFiles?: number, baseBranch?: string): string | undefined;
+/**
+ * Forget that {@link activeNotice} has spoken. **Tests only** — a suite
+ * asserting the once-per-process contract has to observe the first call, and
+ * whichever earlier test filtered first would otherwise have consumed it.
+ */
+export declare function resetDiffDisclosureForTests(): void;
+//# sourceMappingURL=diff-disclosure.d.ts.map

package/dist/diff-disclosure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-disclosure.d.ts","sourceRoot":"","sources":["../src/diff-disclosure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAKH;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAkBpB;AAYD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAepB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAElD"}

package/dist/diff-disclosure.js

@@ -0,0 +1,110 @@
+/**
+ * What diff-aware mode suppressed, said out loud.
+ *
+ * Plan 0071's first instrument. `--changed` (and `check({ diff })`) filter
+ * **reporting**, not evaluation — so a run with every finding suppressed is
+ * indistinguishable from a clean run: exit 0, no output, `total: 0`. That is
+ * the false green ADR-008 exists to prevent, and it is worse here than
+ * elsewhere because the reader chose the flag and then forgot it: CI configures
+ * `--changed` once and every subsequent run reads as clean.
+ *
+ * **The count is derived by the caller, never self-reported.** Each call site
+ * computes `before.length - after.length` around its own `filterToChanged`
+ * call. `DiffFilter` could keep that tally itself, and it deliberately does
+ * not: `CheckOptions.diff` is a structural interface (`DiffFilterLike`), so a
+ * consumer can pass any object with a `filterToChanged` method, and a filter
+ * that under-reports its own suppression would produce exactly the silence
+ * this module exists to break. Caller-side subtraction is a differently-derived
+ * value (ADR-009 rule 5) and it works for filters we did not write.
+ *
+ * **Two surfaces, because only one of them can count.**
+ *
+ * | surface                                  | disclosure           |
+ * | ---------------------------------------- | -------------------- |
+ * | CLI `check --changed`                    | `suppressionNotice`  |
+ * | `checkAll([...])`                        | `suppressionNotice`  |
+ * | `.check({ diff })` / `.warn({ diff })`   | `activeNotice`, once |
+ *
+ * The first two filter once over every collected violation, so they know the
+ * whole number. The per-rule terminals do not: `filterToChanged` is called
+ * once per rule (`execute-rule.ts`), and a diff-aware suite with 79 rules
+ * would print 79 lines — on the channel v0.26.0 made unconditionally visible.
+ * There is no per-run aggregation point on that path, so those terminals state
+ * the **configuration** instead, once per process. A configuration statement
+ * cannot be wrong; a per-rule count presented as a run total would be.
+ *
+ * A `process.on('exit')` flush was considered and rejected: it would let the
+ * per-rule path print one complete total, but a library that installs an exit
+ * hook to deliver a correctness-relevant message has made that message
+ * dependent on stderr surviving process teardown — untestable in the shape the
+ * rest of this project asserts (a real child `vitest run`, bug 0024) without
+ * asserting a race. Stating the configuration is weaker and honest.
+ */
+/** Prefix shared with the rest of the library's stderr output. */
+const TAG = '[eess]';
+/**
+ * One line naming what was suppressed, or `undefined` when nothing was.
+ *
+ * `undefined` rather than an empty string so a call site cannot print a blank
+ * line by forgetting to check — the two callers both feed this straight into
+ * `writeStderr`.
+ *
+ * @param suppressed - `before.length - after.length`, computed by the caller.
+ * @param changedFiles - How many files the filter considered changed, when the
+ *   filter exposes it. A user-supplied `DiffFilterLike` need not, in which case
+ *   the sentence drops that clause rather than guessing.
+ * @param baseBranch - The branch diffed against, when known.
+ */
+export function suppressionNotice(suppressed, changedFiles, baseBranch) {
+    if (suppressed <= 0)
+        return undefined;
+    const findings = suppressed === 1 ? 'finding' : 'findings';
+    // A negative size is `DiffFilter`'s "git was unavailable" sentinel. That path
+    // filters nothing, so `suppressed` is 0 and we never reach here — but the
+    // guard is cheap and keeps the sentinel from ever reaching a user's screen.
+    const scope = changedFiles !== undefined && changedFiles >= 0
+        ? ` outside the ${String(changedFiles)} changed ${changedFiles === 1 ? 'file' : 'files'}`
+        : ' outside the changed files';
+    const since = baseBranch === undefined ? '' : ` (diffed against '${baseBranch}')`;
+    return (`${TAG} Diff-aware mode suppressed ${String(suppressed)} ${findings}${scope}${since}. ` +
+        `Those findings are real and still present — this run did not check them. ` +
+        `Re-run without diff-aware mode to see every finding.`);
+}
+/**
+ * Whether {@link activeNotice} has already spoken in this process.
+ *
+ * Module-scoped rather than per-`DiffFilter`, because the documented pattern
+ * constructs a filter **inline per rule** — `.check({ diff: diffAware('main') })`
+ * in `docs/core-concepts.md:333` and `docs/what-to-check.md:515` — so
+ * per-instance state would still produce one line per rule.
+ */
+let noticed = false;
+/**
+ * State that diff-aware filtering is on, once per process. Returns `undefined`
+ * on every call after the first, and whenever nothing was suppressed.
+ *
+ * Keyed on a call that actually suppressed something: a diff-aware run whose
+ * findings all happen to be in changed files has hidden nothing, and a notice
+ * there would train the reader to skip the line that matters.
+ */
+export function activeNotice(suppressed, changedFiles, baseBranch) {
+    if (suppressed <= 0 || noticed)
+        return undefined;
+    noticed = true;
+    const scope = changedFiles !== undefined && changedFiles >= 0
+        ? `the ${String(changedFiles)} ${changedFiles === 1 ? 'file' : 'files'} changed`
+        : 'the files changed';
+    const since = baseBranch === undefined ? '' : ` since '${baseBranch}'`;
+    return (`${TAG} Diff-aware mode is active: this run reports only findings in ${scope}${since}. ` +
+        `Findings in unchanged files are suppressed and will not appear, however many there are. ` +
+        `Remove \`diff\` from the check options to see every finding.`);
+}
+/**
+ * Forget that {@link activeNotice} has spoken. **Tests only** — a suite
+ * asserting the once-per-process contract has to observe the first call, and
+ * whichever earlier test filtered first would otherwise have consumed it.
+ */
+export function resetDiffDisclosureForTests() {
+    noticed = false;
+}
+//# sourceMappingURL=diff-disclosure.js.map

package/dist/diff-disclosure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-disclosure.js","sourceRoot":"","sources":["../src/diff-disclosure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,kEAAkE;AAClE,MAAM,GAAG,GAAG,QAAQ,CAAA;AAEpB;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAAkB,EAClB,YAAqB,EACrB,UAAmB;IAEnB,IAAI,UAAU,IAAI,CAAC;QAAE,OAAO,SAAS,CAAA;IAErC,MAAM,QAAQ,GAAG,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAA;IAC1D,8EAA8E;IAC9E,0EAA0E;IAC1E,4EAA4E;IAC5E,MAAM,KAAK,GACT,YAAY,KAAK,SAAS,IAAI,YAAY,IAAI,CAAC;QAC7C,CAAC,CAAC,gBAAgB,MAAM,CAAC,YAAY,CAAC,YAAY,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE;QACzF,CAAC,CAAC,4BAA4B,CAAA;IAClC,MAAM,KAAK,GAAG,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAqB,UAAU,IAAI,CAAA;IAEjF,OAAO,CACL,GAAG,GAAG,+BAA+B,MAAM,CAAC,UAAU,CAAC,IAAI,QAAQ,GAAG,KAAK,GAAG,KAAK,IAAI;QACvF,2EAA2E;QAC3E,sDAAsD,CACvD,CAAA;AACH,CAAC;AAED;;;;;;;GAOG;AACH,IAAI,OAAO,GAAG,KAAK,CAAA;AAEnB;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,UAAkB,EAClB,YAAqB,EACrB,UAAmB;IAEnB,IAAI,UAAU,IAAI,CAAC,IAAI,OAAO;QAAE,OAAO,SAAS,CAAA;IAChD,OAAO,GAAG,IAAI,CAAA;IAEd,MAAM,KAAK,GACT,YAAY,KAAK,SAAS,IAAI,YAAY,IAAI,CAAC;QAC7C,CAAC,CAAC,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,UAAU;QAChF,CAAC,CAAC,mBAAmB,CAAA;IACzB,MAAM,KAAK,GAAG,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,UAAU,GAAG,CAAA;IAEtE,OAAO,CACL,GAAG,GAAG,iEAAiE,KAAK,GAAG,KAAK,IAAI;QACxF,0FAA0F;QAC1F,8DAA8D,CAC/D,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,2BAA2B;IACzC,OAAO,GAAG,KAAK,CAAA;AACjB,CAAC"}

package/dist/disk-set.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What the filesystem says about a glob that the compiler's file set does
+ * not — the shape of the data, not how to build it.
+ *
+ * `OnDisk`/`DiskSet` are pure: a materialized `DiskSet` is just a closure
+ * over already-walked filesystem data, so the type stays in the kernel.
+ * Walking a real project's filesystem needs Node's `fs`/`path` and the
+ * dialect's own project type to find the root, so the MATERIALIZER lives in
+ * that dialect (e.g. `packages/ts/src/core/disk-set.ts`'s `diskSet()`).
+ */
+/**
+ * What the filesystem knows that the compiler's file set does not.
+ *
+ * Distinguishes "your glob is misspelled" from "your glob is fine and your
+ * tsconfig scope excludes it" — the cheapest wrong action an agent can take
+ * on a dead-glob finding, and the common case in a real monorepo where a
+ * build-output or docs directory sits outside the loaded project.
+ */
+export type OnDisk = 'holds-typescript' | 'no-typescript' | 'absent' | 'not-determined';
+/**
+ * What the filesystem knows that the compiler's file set does not.
+ */
+export interface DiskSet {
+    /** Classify a glob by what exists on disk under the paths it matches. */
+    classify(glob: string): OnDisk;
+}
+//# sourceMappingURL=disk-set.d.ts.map

package/dist/disk-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk-set.d.ts","sourceRoot":"","sources":["../src/disk-set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,MAAM,GAAG,kBAAkB,GAAG,eAAe,GAAG,QAAQ,GAAG,gBAAgB,CAAA;AAEvF;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAC/B"}

package/dist/disk-set.js

@@ -0,0 +1,12 @@
+/**
+ * What the filesystem says about a glob that the compiler's file set does
+ * not — the shape of the data, not how to build it.
+ *
+ * `OnDisk`/`DiskSet` are pure: a materialized `DiskSet` is just a closure
+ * over already-walked filesystem data, so the type stays in the kernel.
+ * Walking a real project's filesystem needs Node's `fs`/`path` and the
+ * dialect's own project type to find the root, so the MATERIALIZER lives in
+ * that dialect (e.g. `packages/ts/src/core/disk-set.ts`'s `diskSet()`).
+ */
+export {};
+//# sourceMappingURL=disk-set.js.map

package/dist/disk-set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk-set.js","sourceRoot":"","sources":["../src/disk-set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/edge-coverage.d.ts

@@ -0,0 +1,96 @@
+/**
+ * How much evidence an allowlist condition actually had — bug 0015.
+ *
+ * The `only*` family constrains **edges**, not subjects. Each iterates a
+ * subject's imports (or importers) and reports one violation per edge outside
+ * the allowlist, so a subject with **zero edges has nothing to violate and
+ * passes**, however broken the allowlist. Measured: one file with no imports,
+ * `onlyImportFrom('**\/nowhere/**')` → 1 subject selected, 0 violations.
+ *
+ * The shape it fails on is the target case, not an edge case: in a layered
+ * architecture the innermost layer is the one an allowlist protects and is
+ * characteristically the layer with the fewest outbound imports.
+ *
+ * ## Why this reports rather than fails
+ *
+ * [ts-archunit Bug 0015](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0015-allowlist-conditions-pass-vacuously-on-edgeless-subjects.md)
+ * refuted failing, per-subject and per-rule, on measurement:
+ *
+ * - **Per-subject has no statable remedy.** 14 of this repo's `src/` files have
+ *   zero static imports and 10 are pure leaf modules. `tarjan.ts` is a
+ *   dependency-free algorithm — the ideal innermost-layer citizen — and would
+ *   fail at error severity. The remedies available are: add an import (harmful),
+ *   exclude a working rule, narrow the selector, or delete the rule. None
+ *   improves anything, because **for the `only*` family zero edges is maximal
+ *   compliance**, not absent evidence. That fails ADR-009 rule 2.
+ * - **Per-rule multiplies.** Six boundaries and one dependency-free shared file
+ *   make `strictBoundaries` emit 13 rules, **12** with subjects and zero edges.
+ * - **`ignoreTypeImports` inverts it.** Counting edges after the filter means a
+ *   layer whose only dependency is `import type` counts zero and fires on the
+ *   best possible outcome — under the option the docs recommend for layers.
+ *
+ * So the remedy is genuinely optional and the reader must judge it, which under
+ * ADR-009 rule 1 is a disclosure, not a failure. This module is the disclosure.
+ *
+ * ## Why module state rather than a field on `ConditionContext`
+ *
+ * `ConditionContext` is a **public exported type** backing the documented
+ * `defineCondition()`, and bug 0015 records that extending `Condition<T>` for
+ * this was one reason the failing design could not ship. `diff-disclosure.ts`
+ * established the pattern for a run-scoped notice that conditions produce and
+ * the CLI consumes; this follows it, including the test reset.
+ */
+/**
+ * Why a rule tested no edges. The three are not interchangeable, and saying the
+ * wrong one is an ADR-009 rule 2 defect — a stated cause that is wrong for the
+ * input.
+ *
+ * The first version of this module printed "correct for a genuinely
+ * dependency-free module" for all three. Measured, that is false for two of
+ * them: a subject whose imports were filtered by `ignoreTypeImports` **has**
+ * dependencies, and a reader who opens the folder finds them and concludes the
+ * tool is broken; and a rule whose allowlist matched no import is pointing at
+ * the interesting case — the glob may be a typo — which that sentence hides.
+ */
+export type UntestedReason = 
+/** The subjects have no edges of any kind. Usually correct, and the layered case. */
+'no-edges'
+/** Edges existed, and every one was filtered out before the check saw it. */
+ | 'all-filtered'
+/** Edges existed, and none of them matched the allowlist glob. */
+ | 'none-matched';
+/** One rule's evidence: how many subjects it saw and how many edges it tested. */
+export interface EdgeCoverage {
+    readonly rule: string;
+    readonly subjects: number;
+    readonly edges: number;
+    readonly reason: UntestedReason;
+}
+/**
+ * Record what a condition had to work with.
+ *
+ * Keyed on the rule description, and **accumulated** rather than overwritten:
+ * one rule can evaluate its condition more than once (a `.check()` after a
+ * `.violations()`, or the same description in two files), and taking the last
+ * write would report the smaller run.
+ */
+export declare function recordEdgeCoverage(rule: string, subjects: number, edges: number, reason?: UntestedReason): void;
+/**
+ * Rules that had subjects and tested no edges — the vacuous passes.
+ *
+ * A rule with **no subjects** is deliberately excluded: that is an empty
+ * selector, which is `.expectNonEmpty()`'s business and plan 0067's, and
+ * reporting it here would give one fault two owners.
+ */
+export declare function untestedRules(): readonly EdgeCoverage[];
+/**
+ * The disclosure, or `undefined` when every allowlist was exercised.
+ *
+ * Names the rules rather than counting them (ADR-009 rule 4): "3 rules tested
+ * nothing" sends the reader to grep, and the whole point is that they must
+ * judge whether an edge-free population is correct here.
+ */
+export declare function edgeCoverageNotice(): string | undefined;
+/** Drop the tally. The CLI resets per run; tests reset per case. */
+export declare function resetEdgeCoverage(): void;
+//# sourceMappingURL=edge-coverage.d.ts.map

package/dist/edge-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-coverage.d.ts","sourceRoot":"","sources":["../src/edge-coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc;AACxB,qFAAqF;AACnF,UAAU;AACZ,6EAA6E;GAC3E,cAAc;AAChB,kEAAkE;GAChE,cAAc,CAAA;AAElB,kFAAkF;AAClF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;CAChC;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,cAA2B,GAClC,IAAI,CAeN;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI,SAAS,YAAY,EAAE,CAEvD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,SAAS,CA0BvD;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,IAAI,IAAI,CAExC"}

package/dist/edge-coverage.js

@@ -0,0 +1,108 @@
+/**
+ * How much evidence an allowlist condition actually had — bug 0015.
+ *
+ * The `only*` family constrains **edges**, not subjects. Each iterates a
+ * subject's imports (or importers) and reports one violation per edge outside
+ * the allowlist, so a subject with **zero edges has nothing to violate and
+ * passes**, however broken the allowlist. Measured: one file with no imports,
+ * `onlyImportFrom('**\/nowhere/**')` → 1 subject selected, 0 violations.
+ *
+ * The shape it fails on is the target case, not an edge case: in a layered
+ * architecture the innermost layer is the one an allowlist protects and is
+ * characteristically the layer with the fewest outbound imports.
+ *
+ * ## Why this reports rather than fails
+ *
+ * [ts-archunit Bug 0015](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0015-allowlist-conditions-pass-vacuously-on-edgeless-subjects.md)
+ * refuted failing, per-subject and per-rule, on measurement:
+ *
+ * - **Per-subject has no statable remedy.** 14 of this repo's `src/` files have
+ *   zero static imports and 10 are pure leaf modules. `tarjan.ts` is a
+ *   dependency-free algorithm — the ideal innermost-layer citizen — and would
+ *   fail at error severity. The remedies available are: add an import (harmful),
+ *   exclude a working rule, narrow the selector, or delete the rule. None
+ *   improves anything, because **for the `only*` family zero edges is maximal
+ *   compliance**, not absent evidence. That fails ADR-009 rule 2.
+ * - **Per-rule multiplies.** Six boundaries and one dependency-free shared file
+ *   make `strictBoundaries` emit 13 rules, **12** with subjects and zero edges.
+ * - **`ignoreTypeImports` inverts it.** Counting edges after the filter means a
+ *   layer whose only dependency is `import type` counts zero and fires on the
+ *   best possible outcome — under the option the docs recommend for layers.
+ *
+ * So the remedy is genuinely optional and the reader must judge it, which under
+ * ADR-009 rule 1 is a disclosure, not a failure. This module is the disclosure.
+ *
+ * ## Why module state rather than a field on `ConditionContext`
+ *
+ * `ConditionContext` is a **public exported type** backing the documented
+ * `defineCondition()`, and bug 0015 records that extending `Condition<T>` for
+ * this was one reason the failing design could not ship. `diff-disclosure.ts`
+ * established the pattern for a run-scoped notice that conditions produce and
+ * the CLI consumes; this follows it, including the test reset.
+ */
+const coverage = new Map();
+/**
+ * Record what a condition had to work with.
+ *
+ * Keyed on the rule description, and **accumulated** rather than overwritten:
+ * one rule can evaluate its condition more than once (a `.check()` after a
+ * `.violations()`, or the same description in two files), and taking the last
+ * write would report the smaller run.
+ */
+export function recordEdgeCoverage(rule, subjects, edges, reason = 'no-edges') {
+    const prior = coverage.get(rule);
+    // The MINIMUM edge count, not the maximum. Two evaluations of the same rule
+    // description — the same preset over two projects, or the same chain written
+    // twice — merge on this key, and taking the max let a run that tested edges
+    // erase a run that tested none. Measured: the vacuous run vanished from the
+    // report. For a disclosure OF vacuity the conservative direction is to keep
+    // the smaller evidence; over-disclosing costs a footnote, under-disclosing is
+    // the silent pass this module exists to surface.
+    coverage.set(rule, {
+        rule,
+        subjects: Math.max(prior?.subjects ?? 0, subjects),
+        edges: prior === undefined ? edges : Math.min(prior.edges, edges),
+        reason: prior !== undefined && prior.edges <= edges ? prior.reason : reason,
+    });
+}
+/**
+ * Rules that had subjects and tested no edges — the vacuous passes.
+ *
+ * A rule with **no subjects** is deliberately excluded: that is an empty
+ * selector, which is `.expectNonEmpty()`'s business and plan 0067's, and
+ * reporting it here would give one fault two owners.
+ */
+export function untestedRules() {
+    return [...coverage.values()].filter((c) => c.subjects > 0 && c.edges === 0);
+}
+/**
+ * The disclosure, or `undefined` when every allowlist was exercised.
+ *
+ * Names the rules rather than counting them (ADR-009 rule 4): "3 rules tested
+ * nothing" sends the reader to grep, and the whole point is that they must
+ * judge whether an edge-free population is correct here.
+ */
+export function edgeCoverageNotice() {
+    const untested = untestedRules();
+    if (untested.length === 0)
+        return undefined;
+    const because = {
+        'no-edges': 'those subjects have no imports at all, which is correct for a dependency-free module and ' +
+            'means the rule certified nothing otherwise',
+        'all-filtered': 'those subjects DO have imports — every one was excluded by `ignoreTypeImports` before the ' +
+            'check saw it, so the allowlist was never consulted',
+        'none-matched': 'those subjects have imports, and none matched the allowlist glob — so either nothing is ' +
+            'in scope by design, or the glob is wrong',
+    };
+    const lines = untested.map((c) => `  - ${c.rule}\n    ${String(c.subjects)} subject${c.subjects === 1 ? '' : 's'}, 0 edges tested — ${because[c.reason]}.`);
+    const count = untested.length;
+    return (`[eess] ${String(count)} allowlist rule${count === 1 ? '' : 's'} passed without ` +
+        `testing a single edge:\n${lines.join('\n')}\n` +
+        `  An allowlist constrains edges, so a subject with none cannot violate it. Only you can ` +
+        `tell an intended shape from a rule that certified nothing.`);
+}
+/** Drop the tally. The CLI resets per run; tests reset per case. */
+export function resetEdgeCoverage() {
+    coverage.clear();
+}
+//# sourceMappingURL=edge-coverage.js.map

package/dist/edge-coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-coverage.js","sourceRoot":"","sources":["../src/edge-coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AA8BH,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAwB,CAAA;AAEhD;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,IAAY,EACZ,QAAgB,EAChB,KAAa,EACb,SAAyB,UAAU;IAEnC,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAChC,4EAA4E;IAC5E,6EAA6E;IAC7E,4EAA4E;IAC5E,4EAA4E;IAC5E,4EAA4E;IAC5E,8EAA8E;IAC9E,iDAAiD;IACjD,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE;QACjB,IAAI;QACJ,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,IAAI,CAAC,EAAE,QAAQ,CAAC;QAClD,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC;QACjE,MAAM,EAAE,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM;KAC5E,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAA;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,QAAQ,GAAG,aAAa,EAAE,CAAA;IAChC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAA;IAE3C,MAAM,OAAO,GAAmC;QAC9C,UAAU,EACR,2FAA2F;YAC3F,4CAA4C;QAC9C,cAAc,EACZ,4FAA4F;YAC5F,oDAAoD;QACtD,cAAc,EACZ,0FAA0F;YAC1F,0CAA0C;KAC7C,CAAA;IACD,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CACxB,CAAC,CAAC,EAAE,EAAE,CACJ,OAAO,CAAC,CAAC,IAAI,SAAS,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,sBAAsB,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAC3H,CAAA;IACD,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAA;IAC7B,OAAO,CACL,UAAU,MAAM,CAAC,KAAK,CAAC,kBAAkB,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,kBAAkB;QACjF,2BAA2B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;QAC/C,0FAA0F;QAC1F,4DAA4D,CAC7D,CAAA;AACH,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,iBAAiB;IAC/B,QAAQ,CAAC,KAAK,EAAE,CAAA;AAClB,CAAC"}

package/dist/errors.d.ts

@@ -11,4 +11,29 @@ export declare class ArchRuleError extends Error {
     /** The violations that failed the rule, in report order. */
     get violations(): ArchViolation[];
 }
+/**
+ * Is this an `ArchRuleError` — including one thrown by a DIFFERENT copy of this
+ * module?
+ *
+ * `instanceof` is an identity check, and a rule file does not necessarily load
+ * through the same module registry as the CLI that loads it. `load-rules.ts`
+ * uses jiti (bug 0074: a `.ts` rule file must load inside a `"type": "commonjs"`
+ * consumer project), and jiti keeps its own registry — so the `ArchRuleError`
+ * a self-executing rule file throws is a different class object from this one
+ * and `instanceof` is FALSE for an error that is, in every way that matters,
+ * an ArchRuleError.
+ *
+ * Measured: that made `check.ts` skip `ruleFileTruncated()`, so a rule file
+ * whose first rule threw reported the finding and said nothing about the rules
+ * after it that never ran — a silent gap in a red run, which is bug 0029
+ * reopened by the loader. The same hazard exists for any consumer with two
+ * copies of eess-ts on disk (a nested `node_modules`), where the loader is
+ * irrelevant.
+ *
+ * Structural, therefore: the `name` this class stamps in its constructor plus
+ * the `violations` array that is its whole reason to exist. Both are part of the
+ * documented public shape (`ArchViolation[]` on a thrown error), so matching on
+ * them is matching on the contract rather than on a coincidence.
+ */
+export declare function isArchRuleError(error: unknown): error is ArchRuleError;
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,KAAK;;gBAG1B,UAAU,EAAE,aAAa,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM;IAQxD,4DAA4D;IAC5D,IAAI,UAAU,IAAI,aAAa,EAAE,CAEhC;CACF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,KAAK;;gBAG1B,UAAU,EAAE,aAAa,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM;IAQxD,4DAA4D;IAC5D,IAAI,UAAU,IAAI,aAAa,EAAE,CAEhC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAQtE"}