@nielspeter/eess 0.2.2 → 0.5.0

package/dist/cache-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-registry.js","sourceRoot":"","sources":["../src/cache-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,GAAmB,EAAE,CAAA;AAEjC,4DAA4D;AAC5D,MAAM,UAAU,kBAAkB,CAAC,KAAiB;IAClD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACpB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB;IACnC,KAAK,MAAM,KAAK,IAAI,MAAM;QAAE,KAAK,EAAE,CAAA;AACrC,CAAC"}

package/dist/cardinality.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Declare that this condition is satisfied by an empty selection.
+ *
+ * **A registry, because a symbol was forgeable.** The first version keyed a
+ * module-private `unique symbol` onto the condition, reasoning that a consumer
+ * could not import it to name the key. They do not need to import it — four
+ * shipped conditions carry it as an own property, and `notExist` is publicly
+ * exported, so:
+ *
+ * ```ts
+ * const stolen = Object.getOwnPropertySymbols(notExist())[0]
+ * const mine = { description: 'x', evaluate: () => [], [stolen]: true }
+ * ```
+ *
+ * Measured: an honest condition on an empty selection produces **1** configuration
+ * finding and that forgery produces **0**. One line, through documented exports,
+ * to exempt any rule from the empty-selection gate — the gate this library is
+ * named around, and precisely the `.allowEmpty()` hazard the symbol was chosen to
+ * prevent.
+ *
+ * Found by review, immediately after the identical hole was closed in
+ * [ts-archunit plan 0081](https://github.com/nielspeter/ts-archunit/blob/main/plans/completed/0081-a-condition-declares-discovery-ownership.md)'s
+ * symbol — while this one was being cited in that module's docstring as the safe
+ * precedent. The lesson is worth more than the fix: **"module-private" describes
+ * the binding, not the value.** A symbol keyed onto a public object is unlisted,
+ * not unreachable.
+ *
+ * `WeakSet` membership cannot be read off an object, copied, or forged: a caller
+ * would need this module's binding, and it is not exported. Weak so a condition is
+ * not retained after its rule is discarded.
+ */
+export declare function marksAssertsCardinality<T extends object>(condition: T): T;
+/** Is this condition satisfied by an empty selection? */
+export declare function assertsCardinality(condition: object): boolean;
+//# sourceMappingURL=cardinality.d.ts.map

package/dist/cardinality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardinality.d.ts","sourceRoot":"","sources":["../src/cardinality.ts"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,CAGzE;AAED,yDAAyD;AACzD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE7D"}

package/dist/cardinality.js

@@ -0,0 +1,80 @@
+/**
+ * The cardinality exemption, keyed so that only this library can set it.
+ *
+ * Plan 0074 (R3b), and specifically constraint 2 of 0069's appendix:
+ *
+ * > `Condition` is a public export and `defineCondition` is its sanctioned
+ * > constructor. If the flag is expressible there, it is a one-line silent
+ * > opt-out on any user condition — the hazard the Decisions section used to
+ * > reject `.allowEmpty()`, relocated onto the condition object. A
+ * > module-private `unique symbol`, with no `defineCondition` parameter, closes
+ * > it by construction (ADR-009 rule 3's corollary).
+ *
+ * A first cut of this shipped as a plain `assertsCardinality?: true` property,
+ * which is exactly the rejected shape: `Condition` is exported from
+ * `src/index.ts`, so any user object literal could set it and silence the
+ * empty-selection gate on any rule, permanently and invisibly. That is
+ * `.allowEmpty()` wearing a different hat.
+ *
+ * **What actually stops a consumer doing this: not enough.** Say it plainly,
+ * because two earlier versions of this comment did not.
+ *
+ * The `WeakSet` below defends the KEY — membership cannot be read off an object,
+ * copied, or forged. It does not defend the CALL. Anyone holding
+ * `marksAssertsCardinality` can mark any condition, and it is reachable from
+ * `@nielspeter/eess/internal`. The first rationale here ("the exports map has no
+ * wildcard subpath") stopped being true when ADR-011 added the subpath; the
+ * second ("the `WeakSet` is the real defence") was simply wrong about which half
+ * it guards, and was written in the same branch that added the subpath.
+ *
+ * The honest position: this is narrower than it was — on `main` the marker was
+ * exported from the kernel ROOT and re-exported by eess-ts's root, so it sat on
+ * two published surfaces; it is now on one, named `/internal`, which no dialect
+ * re-exports. It is not closed. Closing it means validating at the registration
+ * site (accept only conditions from a sanctioned constructor), which is a design
+ * change, not a comment.
+ *
+ * The escape hatch users are *meant* to have is `.expectEmpty()` — an assertion
+ * that fails when the selection stops being empty, not a silencer.
+ */
+const CARDINALITY_ASSERTERS = new WeakSet();
+/**
+ * Declare that this condition is satisfied by an empty selection.
+ *
+ * **A registry, because a symbol was forgeable.** The first version keyed a
+ * module-private `unique symbol` onto the condition, reasoning that a consumer
+ * could not import it to name the key. They do not need to import it — four
+ * shipped conditions carry it as an own property, and `notExist` is publicly
+ * exported, so:
+ *
+ * ```ts
+ * const stolen = Object.getOwnPropertySymbols(notExist())[0]
+ * const mine = { description: 'x', evaluate: () => [], [stolen]: true }
+ * ```
+ *
+ * Measured: an honest condition on an empty selection produces **1** configuration
+ * finding and that forgery produces **0**. One line, through documented exports,
+ * to exempt any rule from the empty-selection gate — the gate this library is
+ * named around, and precisely the `.allowEmpty()` hazard the symbol was chosen to
+ * prevent.
+ *
+ * Found by review, immediately after the identical hole was closed in
+ * [ts-archunit plan 0081](https://github.com/nielspeter/ts-archunit/blob/main/plans/completed/0081-a-condition-declares-discovery-ownership.md)'s
+ * symbol — while this one was being cited in that module's docstring as the safe
+ * precedent. The lesson is worth more than the fix: **"module-private" describes
+ * the binding, not the value.** A symbol keyed onto a public object is unlisted,
+ * not unreachable.
+ *
+ * `WeakSet` membership cannot be read off an object, copied, or forged: a caller
+ * would need this module's binding, and it is not exported. Weak so a condition is
+ * not retained after its rule is discarded.
+ */
+export function marksAssertsCardinality(condition) {
+    CARDINALITY_ASSERTERS.add(condition);
+    return condition;
+}
+/** Is this condition satisfied by an empty selection? */
+export function assertsCardinality(condition) {
+    return CARDINALITY_ASSERTERS.has(condition);
+}
+//# sourceMappingURL=cardinality.js.map

package/dist/cardinality.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardinality.js","sourceRoot":"","sources":["../src/cardinality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,qBAAqB,GAAG,IAAI,OAAO,EAAU,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,uBAAuB,CAAmB,SAAY;IACpE,qBAAqB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;IACpC,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,kBAAkB,CAAC,SAAiB;IAClD,OAAO,qBAAqB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;AAC7C,CAAC"}

package/dist/check-options.d.ts

@@ -22,6 +22,20 @@ export interface BaselineFilter {
 export interface DiffFilterLike {
     /** Filter violations to only those in changed files. */
     filterToChanged(violations: ArchViolation[]): ArchViolation[];
+    /**
+     * How many files this filter considers changed, or a negative number when it
+     * could not tell (`DiffFilter` returns -1 when git was unavailable).
+     *
+     * **Optional, and the disclosure degrades rather than guesses.** This is a
+     * structural interface, so a consumer may pass any object with
+     * `filterToChanged`; when `size` is absent the suppression notice omits the
+     * file count instead of inventing one. What it never omits is the suppressed
+     * count itself, because the caller derives that by subtraction rather than
+     * asking the filter (see `core/diff-disclosure.ts`).
+     */
+    readonly size?: number;
+    /** The branch diffed against, when the filter knows it. Optional, as `size`. */
+    readonly baseBranch?: string;
 }
 /**
  * Options passed to .check() and .warn() to filter violations.

package/dist/check-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-options.d.ts","sourceRoot":"","sources":["../src/check-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAA;AAEzD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,4DAA4D;IAC5D,SAAS,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAAA;CACxD;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,wDAAwD;IACxD,eAAe,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAAA;CAC9D;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB,iDAAiD;IACjD,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,wDAAwD;IACxD,MAAM,CAAC,EAAE,YAAY,CAAA;CACtB"}
+{"version":3,"file":"check-options.d.ts","sourceRoot":"","sources":["../src/check-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAA;AAEzD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,4DAA4D;IAC5D,SAAS,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAAA;CACxD;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,wDAAwD;IACxD,eAAe,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAAA;IAC7D;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,gFAAgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB,iDAAiD;IACjD,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,wDAAwD;IACxD,MAAM,CAAC,EAAE,YAAY,CAAA;CACtB"}

package/dist/cli-config.d.ts

@@ -0,0 +1,59 @@
+import type { OutputFormat } from './check-options.js';
+/**
+ * The parts of dialect CLI config handling that are the same everywhere.
+ *
+ * **Split along the kernel's existing seam, not behind a new injection point.**
+ * `PathUniverse` sets the pattern: the kernel takes materialized data and the
+ * dialect does the I/O. Here the pure halves are finding the config file and
+ * validating what a loaded module claims — both were byte-identical between
+ * `eess-ts` and `eess-mermaid` (`findConfigFile` scored 100%). The impure half,
+ * actually importing the file, stays in each dialect because it needs `jiti`,
+ * which the kernel cannot depend on.
+ *
+ * That leaves one genuinely shared subtlety in the impure half —
+ * {@link isModuleFormatRefusal} — so it lives here too. It is pure, and it is
+ * the part that is easy to get dangerously wrong.
+ */
+/** Config fields every dialect CLI understands. A dialect may add its own. */
+export interface SharedCliConfig {
+    rules?: string[];
+    format?: OutputFormat | 'auto';
+    watchDirs?: string[];
+}
+/** The first of `filenames` that exists in the working directory. */
+export declare function findConfigFile(filenames: readonly string[]): string | undefined;
+/**
+ * The shared config a loaded module claims, validated.
+ *
+ * Everything is checked rather than trusted: a config file is arbitrary user
+ * code and its default export can be any shape at all. An unrecognised `format`
+ * is dropped rather than passed through, so a typo falls back to the default
+ * instead of reaching a formatter that has no case for it.
+ */
+export declare function extractSharedConfig(mod: unknown): SharedCliConfig;
+/**
+ * Did Node refuse this file for its MODULE FORMAT, rather than for anything the
+ * file does?
+ *
+ * Narrow on purpose. A broad `catch` that fell back to a transpiling loader on
+ * any error would re-execute a rule file that had already run — doubling its
+ * output — and would hide a genuine syntax error behind a second,
+ * differently-worded failure.
+ *
+ * The condition it detects is bug 0074: the CONSUMER project is
+ * `"type": "commonjs"` (what `npm init -y` writes) and the config or rule file
+ * uses ESM syntax.
+ */
+export declare function isModuleFormatRefusal(error: unknown): boolean;
+/**
+ * Refuse a run that named no rule files, saying where to name them.
+ *
+ * Sets `process.exitCode` rather than throwing: the caller is a CLI entry point
+ * that still wants to return normally. Returns whether the run may proceed.
+ *
+ * `configName` is the dialect's own config filename, because "set them in
+ * config" is not an instruction — the two copies of this differed in exactly
+ * that word, one naming the file and one not.
+ */
+export declare function requireRuleFiles(ruleFiles: readonly string[], configName: string): boolean;
+//# sourceMappingURL=cli-config.d.ts.map

package/dist/cli-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-config.d.ts","sourceRoot":"","sources":["../src/cli-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAGtD;;;;;;;;;;;;;;GAcG;AAEH,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAC9B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CACrB;AAID,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAO/E;AAOD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,eAAe,CAiBjE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAO1F"}

package/dist/cli-config.js

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { isRecord } from './type-guards.js';
+const FORMATS = new Set(['terminal', 'json', 'github', 'auto']);
+/** The first of `filenames` that exists in the working directory. */
+export function findConfigFile(filenames) {
+    const cwd = process.cwd();
+    for (const name of filenames) {
+        const candidate = path.join(cwd, name);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+/** Strings from an unknown array, dropping anything that is not one. */
+function stringsOf(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === 'string') : undefined;
+}
+/**
+ * The shared config a loaded module claims, validated.
+ *
+ * Everything is checked rather than trusted: a config file is arbitrary user
+ * code and its default export can be any shape at all. An unrecognised `format`
+ * is dropped rather than passed through, so a typo falls back to the default
+ * instead of reaching a formatter that has no case for it.
+ */
+export function extractSharedConfig(mod) {
+    if (!isRecord(mod) || !('default' in mod))
+        return {};
+    const defaultExport = mod.default;
+    if (!isRecord(defaultExport))
+        return {};
+    const config = {};
+    const format = defaultExport['format'];
+    if (typeof format === 'string' && FORMATS.has(format)) {
+        // Narrowed by the set above; the cast-free form is this re-check.
+        config.format =
+            format === 'terminal' || format === 'json' || format === 'github' ? format : 'auto';
+    }
+    const rules = stringsOf(defaultExport['rules']);
+    if (rules)
+        config.rules = rules;
+    const watchDirs = stringsOf(defaultExport['watchDirs']);
+    if (watchDirs)
+        config.watchDirs = watchDirs;
+    return config;
+}
+/**
+ * Did Node refuse this file for its MODULE FORMAT, rather than for anything the
+ * file does?
+ *
+ * Narrow on purpose. A broad `catch` that fell back to a transpiling loader on
+ * any error would re-execute a rule file that had already run — doubling its
+ * output — and would hide a genuine syntax error behind a second,
+ * differently-worded failure.
+ *
+ * The condition it detects is bug 0074: the CONSUMER project is
+ * `"type": "commonjs"` (what `npm init -y` writes) and the config or rule file
+ * uses ESM syntax.
+ */
+export function isModuleFormatRefusal(error) {
+    if (!(error instanceof SyntaxError))
+        return false;
+    return (error.message.includes('Cannot use import statement outside a module') ||
+        error.message.includes("Unexpected token 'export'"));
+}
+/**
+ * Refuse a run that named no rule files, saying where to name them.
+ *
+ * Sets `process.exitCode` rather than throwing: the caller is a CLI entry point
+ * that still wants to return normally. Returns whether the run may proceed.
+ *
+ * `configName` is the dialect's own config filename, because "set them in
+ * config" is not an instruction — the two copies of this differed in exactly
+ * that word, one naming the file and one not.
+ */
+export function requireRuleFiles(ruleFiles, configName) {
+    if (ruleFiles.length > 0)
+        return true;
+    console.error(`Error: No rule files specified. Pass rule files as arguments or set them in ${configName}.`);
+    process.exitCode = 1;
+    return false;
+}
+//# sourceMappingURL=cli-config.js.map

package/dist/cli-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-config.js","sourceRoot":"","sources":["../src/cli-config.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,EAAE,MAAM,SAAS,CAAA;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAyB3C,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAA;AAE/D,qEAAqE;AACrE,MAAM,UAAU,cAAc,CAAC,SAA4B;IACzD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAA;IACzB,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE,CAAC;QAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;QACtC,IAAI,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;YAAE,OAAO,SAAS,CAAA;IAChD,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,wEAAwE;AACxE,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AACnG,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC;QAAE,OAAO,EAAE,CAAA;IACpD,MAAM,aAAa,GAAG,GAAG,CAAC,OAAO,CAAA;IACjC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;QAAE,OAAO,EAAE,CAAA;IAEvC,MAAM,MAAM,GAAoB,EAAE,CAAA;IAClC,MAAM,MAAM,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAA;IACtC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACtD,kEAAkE;QAClE,MAAM,CAAC,MAAM;YACX,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAA;IACvF,CAAC;IACD,MAAM,KAAK,GAAG,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;IAC/C,IAAI,KAAK;QAAE,MAAM,CAAC,KAAK,GAAG,KAAK,CAAA;IAC/B,MAAM,SAAS,GAAG,SAAS,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAA;IACvD,IAAI,SAAS;QAAE,MAAM,CAAC,SAAS,GAAG,SAAS,CAAA;IAC3C,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAc;IAClD,IAAI,CAAC,CAAC,KAAK,YAAY,WAAW,CAAC;QAAE,OAAO,KAAK,CAAA;IACjD,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,8CAA8C,CAAC;QACtE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAC,CACpD,CAAA;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAA4B,EAAE,UAAkB;IAC/E,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAA;IACrC,OAAO,CAAC,KAAK,CACX,+EAA+E,UAAU,GAAG,CAC7F,CAAA;IACD,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAA;IACpB,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/collect-result.d.ts

@@ -0,0 +1,94 @@
+import type { ArchViolation } from './violation.js';
+/**
+ * The receipt — [ADR-014](../../../adr/014-the-emitter-refuses-a-verdict-without-evidence.md).
+ *
+ * **An `ArchViolation[]` carrying its own evidence**, not an object wrapping
+ * one. That shape is load-bearing and the review measured why: a plain object
+ * turns every untyped consumer green, because `result.length` reads `undefined`
+ * and `undefined > 0` is `false`. An array keeps `.length`, iteration,
+ * `flatMap` and every existing `for…of` working and correct, so a JavaScript
+ * consumer who never reads `examined` still exits non-zero on violations.
+ * "`CollectResult`'s shape by name" is a tidiness argument and it loses to that.
+ *
+ * **The name stays `CollectResult`.** Plan 0235 calls it a "receipt" in prose;
+ * there is deliberately no second exported name for one concept.
+ *
+ * `JSON.stringify` drops an array's own properties, which is why
+ * `formatViolationsJson` carries `examined` across by hand — see the note there.
+ */
+export interface CollectResult extends Array<ArchViolation> {
+    /** Units this rule actually reached its assertion over. The denominator. */
+    readonly examined: number;
+    /** The source loaded nothing at all, before any selection ran. */
+    readonly sourceEmpty?: boolean;
+    /** A caller declared this set legitimately empty, and the claim can expire. */
+    readonly declaredEmpty?: boolean;
+    /**
+     * This rule was never run — explicitly disabled, not merely empty.
+     *
+     * A third state, and it has to be distinguishable from both. A rule that RAN
+     * and examined nothing is dead and the merge must say so. A rule turned off
+     * never ran, so it has no denominator to be suspicious about — and marking it
+     * `declaredEmpty` instead would mint the declaration ADR-014 §3's amendment
+     * refuses to infer from `overrides: { id: 'off' }`.
+     *
+     * **It is falsifiable, like every other declaration here.** A rule that never
+     * ran examined nothing and found nothing, so `notRun` beside a non-zero
+     * `examined` or a violation is `emitter/contradictory-evidence` — checked at
+     * the gate and in the merge. Without that check this would be the one
+     * suppressing flag in the vocabulary that nothing can contradict, which is the
+     * shape ADR-014 §3's amendment exists to refuse.
+     *
+     * The two are not interchangeable: without this, one disabled rule reddened a
+     * whole preset whose other rules examined plenty (measured — `adrEnforcement`
+     * with `adr/valid-tiers` off). With it, a preset where EVERY member is `notRun`
+     * still sums to zero examined with no declaration, so the all-off case reports
+     * exactly as §3 requires.
+     */
+    readonly notRun?: boolean;
+    /**
+     * A specific dead-glob explanation for a zero-examined rule, pre-formatted
+     * by the dialect that computed it (`RuleBuilder.deadGlobDiagnosis()`) — the
+     * kernel never touches picomatch or a project type to build this itself.
+     */
+    readonly deadGlob?: string;
+}
+/** Evidence a caller supplies alongside the violations. */
+export interface Evidence {
+    readonly examined: number;
+    readonly sourceEmpty?: boolean;
+    readonly declaredEmpty?: boolean;
+    readonly notRun?: boolean;
+    readonly deadGlob?: string;
+}
+/**
+ * The one constructor. Every terminal produces its receipt through this.
+ *
+ * **Stamps a FRESH array, deliberately.** `applyFilters` returns the *same
+ * reference* when no exclusion applies, so stamping `examined` onto what it
+ * hands back would mutate whatever a family memoized — a rule's evidence
+ * appearing on someone else's array, changing when it is re-read. The copy is
+ * the cost of not having that bug.
+ */
+export declare function collectResult(violations: readonly ArchViolation[], evidence: Evidence): CollectResult;
+/** Does this value carry evidence at all, or is it a bare array? */
+export declare function hasEvidence(value: readonly ArchViolation[]): value is CollectResult;
+/**
+ * The one merge — ADR-014 §7. Fail-closed, and each rule below is a rule a
+ * hand-rolled sum got wrong somewhere (bug 0205's class: four emitters
+ * restating one rule and disagreeing).
+ *
+ * - **`examined` sums.** Zero members sums to zero — an absent denominator is
+ *   not a large one.
+ * - **`declaredEmpty` requires EVERY zero-contributing member to declare.** A
+ *   `some()` here lets one declared part vouch for a hand-counted zero beside
+ *   it, which is the whole failure this merge exists to prevent.
+ * - **`sourceEmpty` on any member outranks every declaration.** ADR-010 §3's
+ *   precedence: a declaration asserts a fact about a loaded corpus, and over
+ *   an empty source it asserts nothing.
+ * - **A member with no evidence poisons the merge**, rather than being counted
+ *   as zero. A dead member must not be able to hide inside a healthy sum, so
+ *   the result carries no evidence either and the emitter says so.
+ */
+export declare function mergeCollectResults(parts: readonly (readonly ArchViolation[])[]): CollectResult;
+//# sourceMappingURL=collect-result.d.ts.map

package/dist/collect-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-result.d.ts","sourceRoot":"","sources":["../src/collect-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAQnD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAc,SAAQ,KAAK,CAAC,aAAa,CAAC;IACzD,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;IAChC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,2DAA2D;AAC3D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,SAAS,aAAa,EAAE,EACpC,QAAQ,EAAE,QAAQ,GACjB,aAAa,CAWf;AAED,oEAAoE;AACpE,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,KAAK,IAAI,aAAa,CAGnF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,aAAa,EAAE,CAAC,EAAE,GAAG,aAAa,CA0G/F"}

package/dist/collect-result.js

@@ -0,0 +1,142 @@
+import { noReceiptViolation, passWithoutEvidenceViolation, contradictoryEvidenceViolation, sourceEmptyViolation, } from './emitter-findings.js';
+/**
+ * The one constructor. Every terminal produces its receipt through this.
+ *
+ * **Stamps a FRESH array, deliberately.** `applyFilters` returns the *same
+ * reference* when no exclusion applies, so stamping `examined` onto what it
+ * hands back would mutate whatever a family memoized — a rule's evidence
+ * appearing on someone else's array, changing when it is re-read. The copy is
+ * the cost of not having that bug.
+ */
+export function collectResult(violations, evidence) {
+    // `Object.assign` returns the intersection type, so no assertion is needed —
+    // ADR-005. An earlier cut wrote `[...violations] as ArchViolation[] & {…}` and
+    // the repo's own `check:arch` reported it, in the module this plan adds.
+    return Object.assign([...violations], {
+        examined: evidence.examined,
+        ...(evidence.sourceEmpty === true ? { sourceEmpty: true } : {}),
+        ...(evidence.declaredEmpty === true ? { declaredEmpty: true } : {}),
+        ...(evidence.notRun === true ? { notRun: true } : {}),
+        ...(evidence.deadGlob === undefined ? {} : { deadGlob: evidence.deadGlob }),
+    });
+}
+/** Does this value carry evidence at all, or is it a bare array? */
+export function hasEvidence(value) {
+    // `in` narrows without an assertion — ADR-005.
+    return 'examined' in value && typeof value.examined === 'number';
+}
+/**
+ * The one merge — ADR-014 §7. Fail-closed, and each rule below is a rule a
+ * hand-rolled sum got wrong somewhere (bug 0205's class: four emitters
+ * restating one rule and disagreeing).
+ *
+ * - **`examined` sums.** Zero members sums to zero — an absent denominator is
+ *   not a large one.
+ * - **`declaredEmpty` requires EVERY zero-contributing member to declare.** A
+ *   `some()` here lets one declared part vouch for a hand-counted zero beside
+ *   it, which is the whole failure this merge exists to prevent.
+ * - **`sourceEmpty` on any member outranks every declaration.** ADR-010 §3's
+ *   precedence: a declaration asserts a fact about a loaded corpus, and over
+ *   an empty source it asserts nothing.
+ * - **A member with no evidence poisons the merge**, rather than being counted
+ *   as zero. A dead member must not be able to hide inside a healthy sum, so
+ *   the result carries no evidence either and the emitter says so.
+ */
+export function mergeCollectResults(parts) {
+    const violations = parts.flat();
+    if (!parts.every(hasEvidence)) {
+        // A member with no evidence at all. The merge REPORTS it rather than
+        // returning an evidence-free value for the emitter to notice later: the
+        // guarantee is this function's, and deferring it was also the last `as` in
+        // this file (an evidence-free value is not a `CollectResult`).
+        return collectResult([...violations, noReceiptViolation()], { examined: 0 });
+    }
+    // **ADR-014 §7's headline guarantee, and it needs its own pass.** Summing
+    // alone lets a dead member hide: measured, a check examining 0 merged with one
+    // examining 900 produced `examined: 900` and no finding — nine checks in
+    // `check-corpus.mjs`, one of them with a `continue` planted at the top of its
+    // loop, and the total still reads healthy. That is the plan's own top success
+    // criterion, and the field failure proposal 009 records, reproduced inside the
+    // primitive built to prevent it.
+    //
+    // A member is dead when it examined nothing, said nothing, and declared
+    // nothing. One that carries its own finding has spoken; one that declared
+    // empty has been accounted for.
+    // A member that never RAN is not a dead check — it is an absent one, with no
+    // denominator to be suspicious about. Excluding it is what keeps ONE disabled
+    // rule from reddening a preset whose others examined plenty (measured:
+    // `adrEnforcement` with `adr/valid-tiers` off). The all-off case still
+    // reports: every member is then `notRun`, the sum is zero and nobody
+    // declared, which the emitter's own gate catches downstream.
+    // A member whose `notRun` contradicts its own evidence, checked HERE and not
+    // only at the gate: the merged receipt carries no `notRun`, so a contradictory
+    // member is invisible downstream — it would slip through the one door that
+    // could see it. `notRun` is also the flag that exempts a member from the dead
+    // filter below, so an unchecked one is a suppressor with no falsifier (the
+    // asymmetry with `declaredEmpty` an enforcement review found in plan 0235).
+    const contradictory = parts.find((p) => p.notRun === true && (p.examined > 0 || p.length > 0));
+    if (contradictory !== undefined) {
+        return collectResult([...violations, contradictoryEvidenceViolation(contradictory.examined, contradictory.length)], { examined: parts.reduce((n, p) => n + p.examined, 0) });
+    }
+    // **An empty source is a member-level fault, checked HERE for the same reason
+    // the contradictory `notRun` above is** — ADR-014 §4: "an empty source
+    // outranks any declaration and names the source."
+    //
+    // The dead filter below EXEMPTS a `sourceEmpty` member, which is right for
+    // "did this member contribute nothing without saying why" — it said why. But
+    // §4 makes that answer a fault rather than an excuse, so the exemption alone
+    // left the merge disagreeing with the gate about the same receipt: measured,
+    // `finishPreset` reds a `{ examined: 0, sourceEmpty: true, declaredEmpty: true }`
+    // member while `mergeCollectResults([thatMember, aHealthyOne])` was GREEN,
+    // because the healthy sibling's `examined` carries the merged receipt past the
+    // gate's own check. That is the `notRun` asymmetry this ADR already fixed once,
+    // recreated for `sourceEmpty` by the change that fixed it at the gate.
+    const emptySource = parts.find((p) => p.sourceEmpty === true && p.examined === 0);
+    if (emptySource !== undefined) {
+        const summed = parts.reduce((n, p) => n + p.examined, 0);
+        return collectResult([...violations, sourceEmptyViolation()], {
+            examined: summed,
+            // **Only when it is true of the WHOLE.** Stamping it unconditionally
+            // minted a receipt saying "the source loaded nothing" beside a non-zero
+            // sum from healthy siblings — and the gate then contradicted it, blaming a
+            // flag nobody set. Four reviewers measured that on this branch's own
+            // headline scenario. The member-level fact is already carried by the
+            // finding above; the flag describes the merged whole, and of the whole it
+            // is only true when nothing was examined anywhere.
+            sourceEmpty: summed === 0 ? true : undefined,
+        });
+    }
+    const dead = parts.filter((p) => p.examined === 0 &&
+        p.length === 0 &&
+        p.notRun !== true &&
+        p.declaredEmpty !== true &&
+        p.sourceEmpty !== true);
+    if (dead.length > 0 && parts.length > 1) {
+        return collectResult([...violations, passWithoutEvidenceViolation()], {
+            examined: parts.reduce((n, p) => n + p.examined, 0),
+        });
+    }
+    const examined = parts.reduce((n, p) => n + p.examined, 0);
+    const anySourceEmpty = parts.some((p) => p.sourceEmpty === true);
+    return collectResult(violations, {
+        examined,
+        sourceEmpty: anySourceEmpty ? true : undefined,
+        // **Only when the WHOLE verdict examined nothing.** A member's declaration
+        // is about that member: `honestyAtClose` merges three rules and one of them
+        // legitimately declares itself empty while the other two examine plenty.
+        // Propagating that up marked the merged verdict declared-empty over a
+        // non-zero total, and the emitter's expiry then fired on it — correctly,
+        // which is how this was found. The member's own declaration is already
+        // satisfied by its own zero; the merge has nothing to add.
+        //
+        // `every`, not `some`: one declared part must never vouch for a
+        // hand-counted zero beside it.
+        declaredEmpty: !anySourceEmpty &&
+            examined === 0 &&
+            parts.length > 0 &&
+            parts.every((p) => p.declaredEmpty === true)
+            ? true
+            : undefined,
+    });
+}
+//# sourceMappingURL=collect-result.js.map

package/dist/collect-result.js.map

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

package/dist/combinators.d.ts

@@ -22,6 +22,20 @@ export type Matcher<V> = (value: V) => boolean;
  */
 export declare function not<T>(input: Predicate<T>): Predicate<T>;
 export declare function not<V>(input: Matcher<V>): Matcher<V>;
+/**
+ * Every input to `and()`/`or()` must be the same kind.
+ *
+ * `eess-ts` carried a byte-identical copy — `no-copy-paste` reported it at
+ * 100%, with only the noun in the message differing — so the noun is now the
+ * parameter and the check has one owner.
+ *
+ * A `TypeError` and not a filtered result: mixing an object predicate with a
+ * matcher function silently drops one kind (the implementations below filter
+ * by `typeof`), so a rule composed that way would narrow by half of what its
+ * author wrote and pass on the rest. Refusing at composition time is the only
+ * point where the mistake is still visible.
+ */
+export declare function assertHomogeneous<T, V>(inputs: (Predicate<T> | Matcher<V>)[], matcherNoun?: string): void;
 /**
  * Combines predicates or matchers with AND logic.
  *

package/dist/combinators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combinators.d.ts","sourceRoot":"","sources":["../src/combinators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAA;AAE9C;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;AACzD,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAmBrD;;;;;;;;;;;;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,CAAC,EAAE,GAAG,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAe7D;;;;;;;;;;;;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,CAAC,EAAE,GAAG,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"combinators.d.ts","sourceRoot":"","sources":["../src/combinators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG/C;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAA;AAE9C;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;AACzD,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAiBrD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EACpC,MAAM,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,EACrC,WAAW,SAAY,GACtB,IAAI,CAMN;AAED;;;;;;;;;;;;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,CAAC,EAAE,GAAG,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAK7D;;;;;;;;;;;;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,CAAC,EAAE,GAAG,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA"}