@nielspeter/eess-ts 0.2.1 → 0.4.0

package/dist/core/check-all.js

@@ -0,0 +1,96 @@
+import { ArchRuleError } from '@nielspeter/eess';
+import { callerAggregates, writeReport } from './execute-rule.js';
+import { dedupeConfigFindings } from '@nielspeter/eess';
+import { suppressionNotice } from '@nielspeter/eess';
+import { writeStderr } from '@nielspeter/eess';
+import { edgeCoverageNotice, resetEdgeCoverage, untestedRules } from '@nielspeter/eess';
+import { commentSuppressionNotice, resetCommentSuppression } from '@nielspeter/eess';
+/**
+ * Run an array of rules (e.g. a spread preset) and throw one aggregated
+ * `ArchRuleError` if any **error-severity** violation is found. Warn-severity
+ * violations are reported but never throw — the same severity contract as the
+ * CLI `check`. This is the test-file terminal for the returning form:
+ *
+ * ```ts
+ * checkAll(layeredArchitecture(p, opts))
+ * checkAll([...recommended(p), ...layeredArchitecture(p, opts)])
+ * ```
+ *
+ * Each builder's `.violations()` already carries its stamped severity
+ * (via `.asSeverity()`), so aggregation and severity are preserved across the
+ * whole array — one readable error listing every error-severity violation.
+ */
+export function checkAll(rules, options) {
+    // Per run, like `runCheck` — a second `checkAll` in one vitest file must
+    // not inherit the first's rules.
+    resetEdgeCoverage();
+    resetCommentSuppression();
+    // One option, one finding (plan 0074). A preset fans a single bad option out
+    // across every generated rule, and only an aggregation point can see that.
+    let violations = dedupeConfigFindings(rules.flatMap((rule) => rule.violations()));
+    if (options?.baseline) {
+        violations = options.baseline.filterNew(violations);
+    }
+    // `checkAll` filters once for the whole array, so like the CLI it can state
+    // the real number (plan 0071). The per-rule terminals cannot — see
+    // `core/diff-disclosure.ts`.
+    let notice;
+    if (options?.diff) {
+        const before = violations.length;
+        violations = options.diff.filterToChanged(violations);
+        notice = suppressionNotice(before - violations.length, options.diff.size, options.diff.baseBranch);
+        if (notice !== undefined)
+            writeStderr(notice);
+    }
+    // `reason` is rendered as each violation's "Why:" line on the terminal path
+    // (`format.ts`: `v.because ?? reason`), so a RUN-level notice must not travel
+    // that way — it would appear as the justification for an unrelated finding.
+    // `summary.reason` in JSON is genuinely run-level, so it goes there, and
+    // stderr carries it for every other format. Found by sabotage: removing the
+    // `writeStderr` call left the tests green because the notice was reaching
+    // stderr through the "Why:" line instead.
+    // Bug 0203 — the third emitter, and the same contract `executeCheck` and
+    // `deliver()` now honour. A `checkAll()` at module scope used to print its
+    // findings before an aggregating caller saw them, and the caller then reported
+    // the same violations again off the throw below.
+    //
+    // **Suppress exactly what rides the throw, and nothing else** — ADR-008's
+    // amendment, and this function is the case that gives it teeth. The throw at the
+    // bottom carries only the ERROR-severity subset, so warn-severity findings ride
+    // nothing. Suppressing them too is not "the caller will report it", it is
+    // deleting them: measured, four warn findings produced and discarded under
+    // `✓ eess-ts — 4 rules across 1 file · 0 failing`, exit 0. A fake green through
+    // this package's own CLI. The first version of this guard did exactly that.
+    //
+    // The flag defaults to `false`, so `checkAll()` in a test file — where nobody
+    // aggregates — still prints everything, exactly as before.
+    const ridesTheThrow = (v) => (v.severity ?? 'error') === 'error';
+    const toWrite = callerAggregates() ? violations.filter((v) => !ridesTheThrow(v)) : violations;
+    if (toWrite.length > 0 || (!callerAggregates() && options?.format === 'json')) {
+        writeReport(toWrite, options?.format, options?.format === 'json' ? notice : undefined, untestedRules());
+    }
+    // Bug 0015 reaches the in-test path too. `checkAll` is the vitest-side
+    // equivalent of `runCheck`, and a disclosure the recommended runner never
+    // shows is a disclosure that does not exist — the same argument that got
+    // `diagnose()` exported for the vitest half of the audience. The residual,
+    // stated: a bare `.check()` per rule has no run boundary to reset or report
+    // at, so it still shows nothing.
+    if (options?.format !== 'json') {
+        const coverage = edgeCoverageNotice();
+        if (coverage !== undefined)
+            writeStderr(`${coverage}\n`);
+    }
+    // Inline exclusion comments, same footnote position and the same reason. Kept
+    // out of the JSON prose for the same reason coverage is: a consumer parsing
+    // that document gets the identities structurally, not as a sentence to grep.
+    if (options?.format !== 'json') {
+        const suppressed = commentSuppressionNotice();
+        if (suppressed !== undefined)
+            writeStderr(`${suppressed}\n`);
+    }
+    const errors = violations.filter(ridesTheThrow);
+    if (errors.length > 0) {
+        throw new ArchRuleError(errors);
+    }
+}
+//# sourceMappingURL=check-all.js.map

package/dist/core/check-all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-all.js","sourceRoot":"","sources":["../../src/core/check-all.ts"],"names":[],"mappings":"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"}

package/dist/core/combinators.d.ts

@@ -0,0 +1,48 @@
+import type { Predicate } from '@nielspeter/eess';
+import type { TypeMatcher } from './type-matcher.js';
+/**
+ * Negates a predicate or type matcher.
+ *
+ * Accepts both `Predicate<T>` objects (used in `.that()` chains) and
+ * `TypeMatcher` functions (used in `.should()` condition arguments).
+ *
+ * @example
+ * // Negate a predicate:
+ * functions(p).that().satisfy(not(areAsync())).should()...
+ *
+ * // Negate a type matcher:
+ * .should().haveReturnTypeMatching(not(matching(/void/)))
+ */
+export declare function not<T>(input: Predicate<T>): Predicate<T>;
+export declare function not(input: TypeMatcher): TypeMatcher;
+/**
+ * Combines predicates or type matchers with AND logic.
+ *
+ * All inputs must be the same kind: either all `Predicate<T>` or all
+ * `TypeMatcher`. Requires at least one argument.
+ *
+ * @example
+ * // Combine predicates:
+ * functions(p).that().satisfy(and(areAsync(), areExported())).should()...
+ *
+ * // Combine type matchers:
+ * .should().haveReturnTypeMatching(and(matching(/Promise/), not(matching(/void/))))
+ */
+export declare function and<T>(...predicates: Predicate<T>[]): Predicate<T>;
+export declare function and(...matchers: TypeMatcher[]): TypeMatcher;
+/**
+ * Combines predicates or type matchers with OR logic.
+ *
+ * All inputs must be the same kind: either all `Predicate<T>` or all
+ * `TypeMatcher`. Requires at least one argument.
+ *
+ * @example
+ * // Combine predicates:
+ * functions(p).that().satisfy(or(areAsync(), areExported())).should()...
+ *
+ * // Combine type matchers:
+ * .should().haveReturnTypeMatching(or(matching(/Promise/), matching(/Collection/)))
+ */
+export declare function or<T>(...predicates: Predicate<T>[]): Predicate<T>;
+export declare function or(...matchers: TypeMatcher[]): TypeMatcher;
+//# sourceMappingURL=combinators.d.ts.map

package/dist/core/combinators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combinators.d.ts","sourceRoot":"","sources":["../../src/core/combinators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAGpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;AACzD,wBAAgB,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAAA;AAyBpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;AACnE,wBAAgB,GAAG,CAAC,GAAG,QAAQ,EAAE,WAAW,EAAE,GAAG,WAAW,CAAA;AAoB5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;AAClE,wBAAgB,EAAE,CAAC,GAAG,QAAQ,EAAE,WAAW,EAAE,GAAG,WAAW,CAAA"}

package/dist/core/combinators.js

@@ -0,0 +1,56 @@
+import { combineGlobs, negateGlobs } from '@nielspeter/eess';
+export function not(input) {
+    if (typeof input === 'function') {
+        return (type) => !input(type);
+    }
+    return {
+        description: `not (${input.description})`,
+        test: (element) => !input.test(element),
+        // Negation-normal-form push-down: `op` inverts as well as `polarity`.
+        // `not(unsatisfiable)` selects everything, so a negated site is
+        // over-selection rather than vacuity and can never be a fault — but a
+        // `not` nested inside the subtree flips it back, which is why this cannot
+        // just flip polarity. See `negateGlobs`.
+        globs: input.globs && negateGlobs(input.globs),
+    };
+}
+function assertHomogeneous(inputs) {
+    if (inputs.length === 0)
+        return;
+    const firstIsFunction = typeof inputs[0] === 'function';
+    if (inputs.some((i) => (typeof i === 'function') !== firstIsFunction)) {
+        throw new TypeError('Cannot mix Predicate objects and TypeMatcher functions in and()/or()');
+    }
+}
+export function and(...inputs) {
+    assertHomogeneous(inputs);
+    if (typeof inputs[0] === 'function') {
+        const matchers = inputs.filter((input) => typeof input === 'function');
+        const fn = (type) => matchers.every((m) => m(type));
+        return fn;
+    }
+    const predicates = inputs.filter((input) => typeof input !== 'function');
+    return {
+        description: predicates.map((p) => p.description).join(' and '),
+        test: (element) => predicates.every((p) => p.test(element)),
+        // A conjunction selects nothing as soon as ONE input does.
+        globs: combineGlobs('all', predicates.map((p) => p.globs)),
+    };
+}
+export function or(...inputs) {
+    assertHomogeneous(inputs);
+    if (typeof inputs[0] === 'function') {
+        const matchers = inputs.filter((input) => typeof input === 'function');
+        return (type) => matchers.some((m) => m(type));
+    }
+    const predicates = inputs.filter((input) => typeof input !== 'function');
+    return {
+        description: predicates.map((p) => p.description).join(' or '),
+        test: (element) => predicates.some((p) => p.test(element)),
+        // A disjunction selects nothing only when EVERY input does. Inputs that
+        // declare no globs become retained opaque children rather than being
+        // dropped — dropping them here is what would red `or(deadGlob, byName)`.
+        globs: combineGlobs('any', predicates.map((p) => p.globs)),
+    };
+}
+//# sourceMappingURL=combinators.js.map

package/dist/core/combinators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"combinators.js","sourceRoot":"","sources":["../../src/core/combinators.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAiB5D,MAAM,UAAU,GAAG,CAAI,KAAiC;IACtD,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;QAChC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IAC/B,CAAC;IACD,OAAO;QACL,WAAW,EAAE,QAAQ,KAAK,CAAC,WAAW,GAAG;QACzC,IAAI,EAAE,CAAC,OAAU,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;QAC1C,sEAAsE;QACtE,gEAAgE;QAChE,sEAAsE;QACtE,0EAA0E;QAC1E,yCAAyC;QACzC,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC;KAC/C,CAAA;AACH,CAAC;AAED,SAAS,iBAAiB,CAAI,MAAsC;IAClE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAM;IAC/B,MAAM,eAAe,GAAG,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,CAAA;IACvD,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,UAAU,CAAC,KAAK,eAAe,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,SAAS,CAAC,sEAAsE,CAAC,CAAA;IAC7F,CAAC;AACH,CAAC;AAiBD,MAAM,UAAU,GAAG,CAAI,GAAG,MAAsC;IAC9D,iBAAiB,CAAC,MAAM,CAAC,CAAA;IACzB,IAAI,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,CAAC;QACpC,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAwB,EAAE,CAAC,OAAO,KAAK,KAAK,UAAU,CAAC,CAAA;QAC5F,MAAM,EAAE,GAAgB,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;QAChE,OAAO,EAAE,CAAA;IACX,CAAC;IACD,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAyB,EAAE,CAAC,OAAO,KAAK,KAAK,UAAU,CAAC,CAAA;IAC/F,OAAO;QACL,WAAW,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QAC/D,IAAI,EAAE,CAAC,OAAU,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9D,2DAA2D;QAC3D,KAAK,EAAE,YAAY,CACjB,KAAK,EACL,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAC/B;KACF,CAAA;AACH,CAAC;AAiBD,MAAM,UAAU,EAAE,CAAI,GAAG,MAAsC;IAC7D,iBAAiB,CAAC,MAAM,CAAC,CAAA;IACzB,IAAI,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,CAAC;QACpC,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAwB,EAAE,CAAC,OAAO,KAAK,KAAK,UAAU,CAAC,CAAA;QAC5F,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;IAChD,CAAC;IACD,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAyB,EAAE,CAAC,OAAO,KAAK,KAAK,UAAU,CAAC,CAAA;IAC/F,OAAO;QACL,WAAW,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;QAC9D,IAAI,EAAE,CAAC,OAAU,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7D,wEAAwE;QACxE,qEAAqE;QACrE,yEAAyE;QACzE,KAAK,EAAE,YAAY,CACjB,KAAK,EACL,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAC/B;KACF,CAAA;AACH,CAAC"}

package/dist/core/descendant-cache.d.ts

@@ -0,0 +1,36 @@
+import type { Node, SyntaxKind } from 'ts-morph';
+/**
+ * Every descendant of `node` with the given kind, walked once per file version.
+ *
+ * A drop-in replacement for `node.getDescendantsOfKind(kind)`. Returns
+ * `readonly` because the array is shared: a caller that sorted or spliced it
+ * would corrupt every later matcher over the same body.
+ */
+export declare function descendantsOfKind(node: Node, kind: SyntaxKind): readonly Node[];
+/**
+ * Every descendant of `node`, walked once per file version.
+ *
+ * The kind-independent twin of {@link descendantsOfKind}, for `findMatchesBroad`
+ * — the strategy `expression()` and `comment()` take, having no `syntaxKinds` to
+ * narrow by.
+ *
+ * **Measured** on this repository, 1,698 function bodies / 117,949 descendants,
+ * ts-morph's wrapper cache already warm:
+ *
+ *     getDescendants()          49 ms   <- what this removes
+ *     + getText() on each       71 ms
+ *     + regex test on each      68 ms
+ *
+ * The walk is roughly three quarters of a broad matcher's cost; the filter is the
+ * rest and is not shareable — `expression()`'s regex differs per matcher.
+ * (`comment()`'s dedup state was the other half of this until bug 0034 removed
+ * it; the filter is still per-matcher.) End to end, six successive broad
+ * rules over the same bodies: **~57 ms each becomes ~17 ms each.**
+ *
+ * The memory objection — that this retains every wrapper in every body rather
+ * than one kind's worth — does not survive checking. ts-morph's own
+ * `ForgetfulNodeCache` already holds every wrapper it creates for the lifetime of
+ * the `SourceFile`, so the array adds N references, not N objects.
+ */
+export declare function allDescendants(node: Node): readonly Node[];
+//# sourceMappingURL=descendant-cache.d.ts.map

package/dist/core/descendant-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descendant-cache.d.ts","sourceRoot":"","sources":["../../src/core/descendant-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAc,UAAU,EAAE,MAAM,UAAU,CAAA;AA2I5D;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,GAAG,SAAS,IAAI,EAAE,CA0B/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,IAAI,EAAE,CAe1D"}

package/dist/core/descendant-cache.js

@@ -0,0 +1,119 @@
+import { registerCacheReset } from '@nielspeter/eess';
+let byFile = new WeakMap();
+/** The kind-independent walk, in the same per-file lifetime as {@link byFile}. */
+let allByFile = new WeakMap();
+const watched = new WeakSet();
+registerCacheReset(() => {
+    byFile = new WeakMap();
+    allByFile = new WeakMap();
+});
+/**
+ * Register the invalidation listener for a file, once.
+ *
+ * Not once per cache miss: a watch session that re-evaluates rules would
+ * otherwise accumulate one listener per rule execution. Both maps are dropped
+ * together, because the same event invalidates both.
+ *
+ * The closure reads `byFile` / `allByFile` as **live bindings** rather than
+ * capturing them, which is what keeps invalidation working after
+ * `registerCacheReset` replaces the maps. Capturing by value made a post-reset
+ * edit invisible and passed the entire suite — there is a test named for it.
+ */
+function watchOnce(sourceFile) {
+    if (watched.has(sourceFile))
+        return;
+    watched.add(sourceFile);
+    sourceFile.onModified(() => {
+        byFile.delete(sourceFile);
+        allByFile.delete(sourceFile);
+    });
+}
+/**
+ * Whether a cached list can still be read.
+ *
+ * Endpoints only, and that is not a heuristic: ts-morph's
+ * `ForgetfulNodeCache.forgetLastPoint` forgets a whole created-in-block set at
+ * once, so a partially-forgotten list is not a shape the mechanism produces.
+ * Walking the full list on every hit would cost what this module exists to save.
+ */
+function usable(nodes) {
+    const first = nodes[0];
+    if (first === undefined)
+        return true;
+    const last = nodes[nodes.length - 1];
+    return !first.wasForgotten() && last !== undefined && !last.wasForgotten();
+}
+/**
+ * Every descendant of `node` with the given kind, walked once per file version.
+ *
+ * A drop-in replacement for `node.getDescendantsOfKind(kind)`. Returns
+ * `readonly` because the array is shared: a caller that sorted or spliced it
+ * would corrupt every later matcher over the same body.
+ */
+export function descendantsOfKind(node, kind) {
+    const sourceFile = node.getSourceFile();
+    let perNode = byFile.get(sourceFile);
+    if (perNode === undefined) {
+        perNode = new Map();
+        byFile.set(sourceFile, perNode);
+    }
+    watchOnce(sourceFile);
+    let byKind = perNode.get(node);
+    if (byKind === undefined) {
+        byKind = new Map();
+        perNode.set(node, byKind);
+    }
+    const hit = byKind.get(kind);
+    // `usable`, not just `!== undefined`. A forget point forgets the walked
+    // DESCENDANTS while the key node stays live and unforgotten, so serving the
+    // cached list makes the next read throw where an uncached walk succeeded.
+    // Measured as a regression against `main`, through the rule path: 1 violation
+    // before, `InvalidOperationError` after. Re-walking is the correct answer —
+    // the nodes are gone, so the list is simply wrong.
+    if (hit !== undefined && usable(hit))
+        return hit;
+    const walked = node.getDescendantsOfKind(kind);
+    byKind.set(kind, walked);
+    return walked;
+}
+/**
+ * Every descendant of `node`, walked once per file version.
+ *
+ * The kind-independent twin of {@link descendantsOfKind}, for `findMatchesBroad`
+ * — the strategy `expression()` and `comment()` take, having no `syntaxKinds` to
+ * narrow by.
+ *
+ * **Measured** on this repository, 1,698 function bodies / 117,949 descendants,
+ * ts-morph's wrapper cache already warm:
+ *
+ *     getDescendants()          49 ms   <- what this removes
+ *     + getText() on each       71 ms
+ *     + regex test on each      68 ms
+ *
+ * The walk is roughly three quarters of a broad matcher's cost; the filter is the
+ * rest and is not shareable — `expression()`'s regex differs per matcher.
+ * (`comment()`'s dedup state was the other half of this until bug 0034 removed
+ * it; the filter is still per-matcher.) End to end, six successive broad
+ * rules over the same bodies: **~57 ms each becomes ~17 ms each.**
+ *
+ * The memory objection — that this retains every wrapper in every body rather
+ * than one kind's worth — does not survive checking. ts-morph's own
+ * `ForgetfulNodeCache` already holds every wrapper it creates for the lifetime of
+ * the `SourceFile`, so the array adds N references, not N objects.
+ */
+export function allDescendants(node) {
+    const sourceFile = node.getSourceFile();
+    let perNode = allByFile.get(sourceFile);
+    if (perNode === undefined) {
+        perNode = new Map();
+        allByFile.set(sourceFile, perNode);
+    }
+    watchOnce(sourceFile);
+    const hit = perNode.get(node);
+    if (hit !== undefined && usable(hit))
+        return hit;
+    const walked = node.getDescendants();
+    perNode.set(node, walked);
+    return walked;
+}
+//# sourceMappingURL=descendant-cache.js.map

package/dist/core/descendant-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descendant-cache.js","sourceRoot":"","sources":["../../src/core/descendant-cache.ts"],"names":[],"mappings":"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"}

package/dist/core/diagnose.d.ts

@@ -0,0 +1,234 @@
+import type { ArchProject } from './project.js';
+import type { GlobPosition } from '@nielspeter/eess';
+import type { GlobFault } from './glob-diagnosis.js';
+import type { OnDisk } from './disk-set.js';
+import type { RuleBuilderLike } from '@nielspeter/eess';
+import type { GlobNode } from '@nielspeter/eess';
+/**
+ * Anything `diagnose()` can inspect: a rule that can describe its globs.
+ *
+ * Structural rather than `TerminalBuilder`, so a caller can pass the same
+ * `RuleBuilderLike[]` array they already hand to `checkAll` without any
+ * of it being coupled to a class.
+ */
+export interface DiagnosableRule extends RuleBuilderLike {
+    globs?: () => readonly GlobNode[];
+    describeRule?: () => {
+        rule: string;
+        id?: string;
+    };
+    /**
+     * Whether this rule asserts anything about what it selected.
+     *
+     * A method rather than a look at `_conditions`: that field is protected, and
+     * reading it would need a type assertion (ADR-005) to duck-type a private
+     * name that no subclass is obliged to keep. Optional, because only the
+     * predicate/condition builders can be in the condition-less state at all —
+     * the rest take their condition as a constructor argument.
+     */
+    assertsSomething?: () => boolean;
+    /**
+     * The remedy for this rule's assertion-less state. When present, `diagnose`
+     * reports it VERBATIM as the finding's advice, so the doctor and the
+     * configuration finding the gate raises at runtime carry the same string by
+     * construction (plan 0070) — they were measured diverging, and two texts for
+     * one state is a trust problem for an agent diffing them. Absent, the base
+     * `TerminalBuilder` text is used, from the one place that owns it.
+     */
+    assertionAdvice?: () => string;
+    /** The project this rule was built against. */
+    getProject?: () => ArchProject | undefined;
+    /**
+     * How many units this rule's family examined — plan 0096.
+     *
+     * PUBLIC because `DiagnosableRule` is structural: a protected member cannot
+     * satisfy it, which is the recorded reason `assertsSomething()` is public.
+     *
+     * The unit differs per family and each names its own (ADR-010 part 1), but
+     * every family answers it from the SAME method its `collectViolations()` uses
+     * — not a parallel derivation. A first attempt at this plan let the two
+     * diverge and they disagreed within one commit.
+     *
+     * Calling it RUNS that materialization. `diagnose()` and `doctor` used to
+     * promise they reported "without running any of them"; that sentence changed
+     * with this plan, in the docs as well as here.
+     */
+    examinedUnits?: () => number;
+    /**
+     * Whether this rule's emptiness was DECLARED — plan 0097, read here by 0096.
+     *
+     * Public for the same structural reason as `assertsSomething()`. Without it
+     * the preview reports a finding on a rule the gate will accept, and tells the
+     * reader to do the thing they already did.
+     */
+    declaresEmpty?: () => boolean;
+    /**
+     * This rule's own zero-subjects advice — plan 0099.
+     *
+     * When present, reported VERBATIM, exactly as `assertionAdvice()` is and for
+     * the identical reason plan 0070 recorded: the doctor and the finding the gate
+     * raises must carry the same string **by construction**, because two texts for
+     * one state is a trust problem for an agent diffing them.
+     *
+     * Measured before this seam existed: `check()` said "a declaration is an
+     * assertion, not a silencer" while `doctor` still said "the declaration is not
+     * itself checked yet ... A later release makes this state fail at check time" —
+     * in the release that makes it fail, on the surface ts-archunit's `docs/upgrading.md` tells
+     * people to run first.
+     */
+    zeroSubjectsAdvice?: () => string;
+    /**
+     * How this family spells the declaration. Absent means the generic
+     * `.expectEmpty()`, which is a `TypeError` on `crossProject` — see
+     * `TerminalBuilder.emptyDeclarationAdvice()`.
+     */
+    emptyDeclarationAdvice?: () => string;
+    /**
+     * Whether a condition on this rule declares emptiness as its PASSING state —
+     * `.notExist()` and friends. Zero examined is the assertion succeeding, so the
+     * evidence check must not report it. See `TerminalBuilder.assertsCardinality()`
+     * for why this is separate from `declaresEmpty()`.
+     */
+    assertsCardinality?: () => boolean;
+    /**
+     * This rule's own adequacy advice — plan 0102.
+     *
+     * Distinct from `zeroSubjectsAdvice`: that covers `examinedUnits() === 0`.
+     * This covers a rule whose evidence is non-empty but which is structurally
+     * unable to ever produce a finding as configured (bug 0077(A) — a
+     * divergence-policing detector on a majority-less corpus). Returns the empty
+     * string for any rule that is not inert, so `diagnose()` reports nothing for
+     * a healthy control. Reported VERBATIM, exactly as `zeroSubjectsAdvice` is,
+     * for the same plan-0070 reason: the preview and the check-time finding must
+     * carry the same string by construction, not two texts for one state.
+     */
+    inertAdvice?: () => string;
+    /**
+     * This rule's own deferred-warning advice — plan 0090.
+     *
+     * A DEFERRED warning (`.asSeverity('warn', { accepted })`) stays `warn` only
+     * for violations whose subject is in `accepted`; this reports when a CURRENT
+     * violation is not — the exact regression an accepted list exists to catch.
+     * Returns `''` for an advisory warning, for a rule at `'error'` severity, and
+     * for a deferred warning whose findings are all still accepted, matching
+     * `inertAdvice`/`zeroSubjectsAdvice`'s own precedent: reported VERBATIM, so
+     * `doctor`'s preview and `checkAll()`/CLI `check`'s eventual failure carry the
+     * same string by construction.
+     */
+    deferredWarningAdvice?: () => string;
+}
+/** One thing wrong with one rule, named specifically enough to fix. */
+export interface DiagnosticFinding {
+    /**
+     * `'project-empty'` — the project loaded no files, so nothing can match and
+     * the globs are not the fault (bug 0031); `'dead-glob'` — a glob that can
+     * never match; `'no-condition'` — a rule
+     * that asserts nothing; `'project-unknown'` — a rule whose globs could not
+     * be checked because it cannot name the project it was built against.
+     */
+    readonly kind: 'dead-glob' | 'no-condition' | 'project-unknown' | 'project-empty'
+    /**
+     * A rule that examined **zero units** while its project loaded files, and
+     * for which nothing else explained the emptiness — plan 0096.
+     *
+     * The preview for plan 0098, which makes the same state FAIL. Distinct from
+     * `'project-empty'` (the instrument loaded nothing) and from `'dead-glob'`
+     * (a glob the author wrote matches nothing): this is the family's OWN
+     * filters removing everything, including defaults the author never wrote.
+     *
+     * It lands in `diagnose()` rather than in `doctor` so that a rule file
+     * importing a test runner — which `doctor` cannot load, ADR-009 rule 1's
+     * corollary — still gets a preview: `expect(diagnose(rules)).toEqual([])`
+     * runs inside the consumer's own suite.
+     */
+     | 'zero-subjects'
+    /**
+     * A rule whose evidence is non-empty but which is structurally unable to
+     * ever produce a finding as configured — plan 0102. Distinct from
+     * `'zero-subjects'`: that fires when `examinedUnits() === 0`; this fires
+     * when `examinedUnits() > 0` but the family's own adequacy predicate
+     * (`inertAdvice?()`) says the rule can never fail regardless. ADR-009's
+     * Notes hand this class to ADR-008 explicitly: "a check can examine 500
+     * subjects and still assert nothing worth knowing."
+     */
+     | 'inert'
+    /**
+     * An inline `// eess-exclude` comment naming a rule id no rule
+     * declares, so it suppresses nothing — [ts-archunit bug 0044](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0044-an-inline-exclusion-comment-has-no-feedback-channel.md).
+     *
+     * Produced by `orphanExclusions()`, never by `diagnose()`: it needs every
+     * rule at once, and `diagnose()` is called per rule file.
+     */
+     | 'orphan-exclusion'
+    /**
+     * A DEFERRED warning (`.asSeverity('warn', { accepted })`) whose current
+     * findings are not all covered by `accepted` — plan 0090. The preview for
+     * the escalation `.violations()`/`checkAll()`/CLI `check` already apply: one
+     * of those findings will report at `error` severity the moment this rule
+     * runs. Distinct from `'inert'` and `'zero-subjects'`, which are about
+     * whether a rule can ever fail; this is about a rule that already fails,
+     * previewed before the run that discovers it does.
+     */
+     | 'deferred-warning';
+    /** The rule's id if it has one, else its assembled description. */
+    readonly rule: string;
+    /** Where the glob was written: `resideInFolder("**\/src/x/**")`. */
+    readonly origin?: string;
+    readonly glob?: string;
+    readonly position?: GlobPosition;
+    readonly fault?: GlobFault;
+    readonly onDisk?: OnDisk;
+    /** The sanctioned fix, or an honest list of causes where none is verifiable. */
+    readonly advice: string;
+    /**
+     * For `'orphan-exclusion'`, the line the comment sits on.
+     */
+    readonly line?: number;
+    /**
+     * For `'orphan-exclusion'`, the **source** file holding the comment.
+     *
+     * Distinct from `ruleFile`, which names where a *rule* was written. An earlier
+     * revision reused `ruleFile` for this and gave JSON consumers two different
+     * things under one name depending on `kind`.
+     */
+    readonly sourceFile?: string;
+    /**
+     * The rule file this rule was written in, when the caller knows it.
+     *
+     * `diagnose()` never sets this — it is handed rules, not files, and inventing
+     * a path it cannot verify is the thing this library exists to stop. `doctor`
+     * sets it, because its loop over rule files is the only place the mapping
+     * exists (bug 0026: `docs/cli.md` claimed identities "in which rule" and that
+     * was true of a dead glob's position and false of every `no-condition`
+     * finding, whose only identity was a prose sentence).
+     */
+    readonly ruleFile?: string;
+}
+/**
+ * Report what each rule cannot enforce, without evaluating their conditions.
+ *
+ * It DOES materialize each rule's selection, as of plan 0096 — "this rule
+ * examined nothing" is a fact about the selection. The docstring said "without
+ * running any of them" and that stopped being true; it is the IDE-hover contract
+ * for an exported function, so it is corrected here and not only in `docs/`.
+ *
+ * As of plan 0102, one family's `inertAdvice?()` goes further than selection:
+ * `inconsistentSiblings` walks every sibling body's AST to answer it (the same
+ * work `check()` does), so for that one family this IS evaluating the
+ * condition, not just counting what would be handed to it (review: architect).
+ * Still no `Condition.evaluate()` call — the boundary this docstring's
+ * predecessor drew — but "without evaluating" is no longer exactly right for
+ * every family, and is corrected here rather than left for the next reader to
+ * discover by profiling `doctor`.
+ *
+ * The in-process half of `doctor`. It exists because rules written inside
+ * vitest are a co-equal documented path (`docs/running-in-tests.md`), and a
+ * CLI-only diagnostic would leave half the users unable to measure before R3
+ * flips anything — which is the one job R2a has.
+ *
+ * Reports **identities, never totals**: which glob, in which rule, at which
+ * position. A count is a snapshot, and under ADR-009 rule 4 a snapshot is the
+ * thing that rots. Callers who want a number can take `.length`.
+ */
+export declare function diagnose(rules: readonly DiagnosableRule[], project?: ArchProject): DiagnosticFinding[];
+//# sourceMappingURL=diagnose.d.ts.map

package/dist/core/diagnose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnose.d.ts","sourceRoot":"","sources":["../../src/core/diagnose.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,kBAAkB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAO3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGhD;;;;;;GAMG;AACH,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,KAAK,CAAC,EAAE,MAAM,SAAS,QAAQ,EAAE,CAAA;IACjC,YAAY,CAAC,EAAE,MAAM;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAClD;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,OAAO,CAAA;IAChC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,MAAM,CAAA;IAC9B,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,WAAW,GAAG,SAAS,CAAA;IAC1C;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,EAAE,MAAM,MAAM,CAAA;IAC5B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,OAAO,CAAA;IAE7B;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,EAAE,MAAM,MAAM,CAAA;IAEjC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,MAAM,CAAA;IAErC;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,OAAO,CAAA;IAElC;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,EAAE,MAAM,MAAM,CAAA;IAE1B;;;;;;;;;;;OAWG;IACH,qBAAqB,CAAC,EAAE,MAAM,MAAM,CAAA;CACrC;AAED,uEAAuE;AACvE,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EACT,WAAW,GACX,cAAc,GACd,iBAAiB,GACjB,eAAe;IACjB;;;;;;;;;;;;;OAaG;OACD,eAAe;IACjB;;;;;;;;OAQG;OACD,OAAO;IACT;;;;;;OAMG;OACD,kBAAkB;IACpB;;;;;;;;OAQG;OACD,kBAAkB,CAAA;IACtB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAA;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,OAAO,CAAC,EAAE,WAAW,GACpB,iBAAiB,EAAE,CA2MrB"}