@nielspeter/eess 0.2.2 → 0.5.0

package/dist/path-suffix.js

@@ -0,0 +1,73 @@
+/**
+ * Resolve a cited path against a set of repo-relative paths.
+ *
+ * Two dialects had written this independently — `eess-md`'s `uniqueSuffix()`
+ * for `path:line` code pointers, and `eess-crossvalidate`'s `resolveFeature`
+ * for `.feature` citations. Same algorithm, same three-way answer, and after
+ * bug 0254 the same remedy text; bug 0257 is that duplication.
+ *
+ * **Why the kernel.** It is pure string work over a list of paths: no
+ * `ArchProject`, no ts-morph, nothing dialect-shaped. That is exactly
+ * `path-universe.ts`'s argument for living here, and
+ * [ADR-013](../../../adr/013-the-kernel-takes-the-fact-not-the-project.md)'s
+ * test is satisfied — the kernel takes the *fact* (a list of paths), not the
+ * project that produced it. It is family plumbing rather than public API, so it
+ * is exported from `internal.ts` (ADR-011).
+ *
+ * **What it deliberately does not decide.** Whether a `none` is broken, whether
+ * an `ambiguous` fails or warns, whether to consult external roots, what the
+ * message says — all of that is the caller's policy and differs between the two
+ * dialects for good reasons. This answers one question: *which path did they
+ * mean?*
+ */
+/**
+ * Prepare a path set for repeated suffix lookups.
+ *
+ * Indexed by last segment, because the corpora this runs over resolve hundreds
+ * of citations against thousands of paths and a linear scan per citation was
+ * measurable in `eess-md`. The index is the reason this takes the whole set up
+ * front rather than being a plain two-argument function.
+ */
+export function pathSuffixIndex(paths) {
+    // Deduplicated on entry, not assumed deduplicated. `all` was always a `Set`,
+    // but the per-segment lists used to push every element of the iterable — so a
+    // path appearing twice came back as `{ kind: 'ambiguous', files: [x, x] }`:
+    // one file reported as ambiguous with itself. Unreachable through today's two
+    // callers (both hand it a set or a filesystem walk), which is exactly why it
+    // would have waited for the third — the parameter is an `Iterable<string>`
+    // and nothing in the type says the caller must have deduplicated. Found by
+    // differential fuzzing across 20,000 cases; it was the only class of
+    // disagreement with the implementations this replaced.
+    const all = new Set(paths);
+    const byLastSegment = new Map();
+    for (const rel of all) {
+        const seg = rel.slice(rel.lastIndexOf('/') + 1);
+        const list = byLastSegment.get(seg);
+        if (list)
+            list.push(rel);
+        else
+            byLastSegment.set(seg, [rel]);
+    }
+    return {
+        resolve(wanted) {
+            // Exact first, and it wins outright. A citation that IS a real path is not
+            // ambiguous just because some longer path happens to end the same way —
+            // both dialects had this precedence already, and getting it backwards
+            // would turn correct citations into findings.
+            if (all.has(wanted))
+                return { kind: 'exact', file: wanted };
+            const seg = wanted.slice(wanted.lastIndexOf('/') + 1);
+            // Narrow by last segment, then confirm the FULL suffix on a `/` boundary:
+            // `x.ts` must not match `prefix-x.ts`, and `a/x.ts` must not match
+            // `b/aa/x.ts`.
+            const matches = (byLastSegment.get(seg) ?? []).filter((f) => f.endsWith('/' + wanted));
+            const only = matches[0];
+            if (matches.length === 1 && only !== undefined)
+                return { kind: 'unique', file: only };
+            if (matches.length > 1)
+                return { kind: 'ambiguous', files: matches };
+            return { kind: 'none' };
+        },
+    };
+}
+//# sourceMappingURL=path-suffix.js.map

package/dist/path-suffix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-suffix.js","sourceRoot":"","sources":["../src/path-suffix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAkBH;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,KAAuB;IACrD,6EAA6E;IAC7E,8EAA8E;IAC9E,4EAA4E;IAC5E,8EAA8E;IAC9E,6EAA6E;IAC7E,2EAA2E;IAC3E,2EAA2E;IAC3E,qEAAqE;IACrE,uDAAuD;IACvD,MAAM,GAAG,GAAG,IAAI,GAAG,CAAS,KAAK,CAAC,CAAA;IAClC,MAAM,aAAa,GAAG,IAAI,GAAG,EAAoB,CAAA;IACjD,KAAK,MAAM,GAAG,IAAI,GAAG,EAAE,CAAC;QACtB,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;QAC/C,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACnC,IAAI,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;;YACnB,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;IACpC,CAAC;IAED,OAAO;QACL,OAAO,CAAC,MAAc;YACpB,2EAA2E;YAC3E,wEAAwE;YACxE,sEAAsE;YACtE,8CAA8C;YAC9C,IAAI,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC;gBAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;YAE3D,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;YACrD,0EAA0E;YAC1E,mEAAmE;YACnE,eAAe;YACf,MAAM,OAAO,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,CAAA;YACtF,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;YACvB,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,KAAK,SAAS;gBAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;YACrF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;gBAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA;YACpE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;QACzB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/path-universe.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Every path a glob could legitimately match in a project — the shape of the
+ * data, not how to build it.
+ *
+ * `PathUniverse` and `viewsFor` are pure: given the materialized string
+ * arrays, they need no `ArchProject`/ts-morph and stay in the kernel. Only
+ * the MATERIALIZER — walking a real project's source files into this shape —
+ * needs the dialect's own project type, and lives in that dialect (e.g.
+ * `packages/ts/src/core/path-universe.ts`'s `pathUniverse()`).
+ */
+export interface PathUniverse {
+    /** Absolute paths of every file in the project. */
+    readonly filePaths: readonly string[];
+    /**
+     * Immediate parent directories only.
+     *
+     * Not all ancestors. A directory-matching predicate typically tests
+     * `filePath.substring(0, filePath.lastIndexOf('/'))` — the immediate
+     * parent and nothing else — so an all-ancestors set is not a harmless
+     * over-approximation, it is a false green: many ancestors are no file's
+     * direct parent, so a glob naming one of those can never select anything
+     * while an all-ancestors universe would call it satisfiable.
+     */
+    readonly parentDirs: readonly string[];
+    /** `filePaths` relative to the tsconfig directory, for message wording. */
+    readonly tsconfigRelativeFilePaths: readonly string[];
+    /** `parentDirs` relative to the tsconfig directory, for message wording. */
+    readonly tsconfigRelativeParentDirs: readonly string[];
+}
+/**
+ * The views a glob of this kind is matched against.
+ *
+ * Satisfiability is taken against the **union** — a glob is unsatisfiable
+ * only when nothing in any view matches it. That is deliberately generous,
+ * so that a wrong `base` cannot make a glob look unmatched by accident. It
+ * does NOT make `base` message-only: the anchor check in `syntacticFault`
+ * consults it directly, and an unanchored `base: 'absolute'` glob is dead
+ * regardless of what any view holds — see `GlobBase`.
+ *
+ * `import-target`, `specifier` and `literal` are not path kinds and have no
+ * views, so they can never be found unsatisfiable here.
+ */
+export declare function viewsFor(universe: PathUniverse, kind: 'file-path' | 'parent-dir' | 'import-target' | 'specifier' | 'literal'): readonly (readonly string[])[];
+//# sourceMappingURL=path-universe.d.ts.map

package/dist/path-universe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-universe.d.ts","sourceRoot":"","sources":["../src/path-universe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,2EAA2E;IAC3E,QAAQ,CAAC,yBAAyB,EAAE,SAAS,MAAM,EAAE,CAAA;IACrD,4EAA4E;IAC5E,QAAQ,CAAC,0BAA0B,EAAE,SAAS,MAAM,EAAE,CAAA;CACvD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,WAAW,GAAG,YAAY,GAAG,eAAe,GAAG,WAAW,GAAG,SAAS,GAC3E,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAIhC"}

package/dist/path-universe.js

@@ -0,0 +1,21 @@
+/**
+ * The views a glob of this kind is matched against.
+ *
+ * Satisfiability is taken against the **union** — a glob is unsatisfiable
+ * only when nothing in any view matches it. That is deliberately generous,
+ * so that a wrong `base` cannot make a glob look unmatched by accident. It
+ * does NOT make `base` message-only: the anchor check in `syntacticFault`
+ * consults it directly, and an unanchored `base: 'absolute'` glob is dead
+ * regardless of what any view holds — see `GlobBase`.
+ *
+ * `import-target`, `specifier` and `literal` are not path kinds and have no
+ * views, so they can never be found unsatisfiable here.
+ */
+export function viewsFor(universe, kind) {
+    if (kind === 'file-path')
+        return [universe.filePaths, universe.tsconfigRelativeFilePaths];
+    if (kind === 'parent-dir')
+        return [universe.parentDirs, universe.tsconfigRelativeParentDirs];
+    return [];
+}
+//# sourceMappingURL=path-universe.js.map

package/dist/path-universe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-universe.js","sourceRoot":"","sources":["../src/path-universe.ts"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,QAAQ,CACtB,QAAsB,EACtB,IAA4E;IAE5E,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,yBAAyB,CAAC,CAAA;IACzF,IAAI,IAAI,KAAK,YAAY;QAAE,OAAO,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,0BAA0B,CAAC,CAAA;IAC5F,OAAO,EAAE,CAAA;AACX,CAAC"}

package/dist/predicate.d.ts

@@ -1,3 +1,4 @@
+import type { DeclaredGlobs } from './glob-site.js';
 /**
  * A predicate that tests whether an architectural element matches a condition.
  * Used in `.that()` clauses to filter elements before rule evaluation.
@@ -7,5 +8,49 @@ export interface Predicate<T> {
     readonly description: string;
     /** Returns true if the element matches this predicate. */
     test(element: T): boolean;
+    /**
+     * The path globs this predicate matches against, if any.
+     *
+     * Declaring them lets the builder answer "can this rule ever have subjects?"
+     * without running it (plan 0069). Optional: a predicate that matches on
+     * something other than a path — a name, a decorator, a type — declares
+     * nothing and is treated as opaque, which is never a fault.
+     *
+     * Leaves are `DeclaredGlob`, so a predicate cannot claim a `position`; the
+     * builder stamps that on according to where the predicate was registered.
+     */
+    readonly globs?: DeclaredGlobs;
+    /**
+     * What to call this predicate's globs in a **configuration finding**, when
+     * the call the user made is not the call the predicate makes.
+     *
+     * Plan 0074, the second consequence of 0069's appendix item 4: presets must
+     * thread the option name into the site's origin (`shared: "…"`, not
+     * `resideInFolder("…")`), or the message names a call the user never made.
+     *
+     * A preset option is one name that expands to several predicates —
+     * `shared: ['…']` becomes `atPath()`, which is `or(resideInFile,
+     * resideInFolder)`. Measured before this existed, the finding read "This
+     * rule's selector reside in file matching … or reside in folder matching …
+     * can never match anything", naming two calls the author never wrote and
+     * omitting the option they did.
+     *
+     * Deliberately **not** `description`, which is overloaded: that renders the
+     * human-readable rule text, and rewriting it would change every violation
+     * message the preset produces, not just the configuration finding.
+     */
+    readonly originLabel?: string;
 }
+/**
+ * Record a predicate on a builder, noting it if it arrived after `.should()`.
+ *
+ * A free function for the same reason as `recordExclusions` and
+ * `selectMatching`: the two builders sit in incompatible hierarchies, so there
+ * is no common base to hold a method. The copies were 94% similar and differed
+ * only in comment wording and braces — no behaviour.
+ *
+ * `phase` is read, never written: recording a misplaced predicate is a
+ * diagnosis, not a state change.
+ */
+export declare function recordPredicate<T>(predicate: Predicate<T>, predicates: Predicate<T>[], misplaced: string[], phase: string): void;
 //# sourceMappingURL=predicate.d.ts.map

package/dist/predicate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../src/predicate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,4FAA4F;IAC5F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,0DAA0D;IAC1D,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAA;CAC1B"}
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../src/predicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,4FAA4F;IAC5F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,0DAA0D;IAC1D,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAA;IACzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAA;IAE9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EACvB,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,EAC1B,SAAS,EAAE,MAAM,EAAE,EACnB,KAAK,EAAE,MAAM,GACZ,IAAI,CAON"}

package/dist/predicate.js

@@ -1,2 +1,21 @@
-export {};
+/**
+ * Record a predicate on a builder, noting it if it arrived after `.should()`.
+ *
+ * A free function for the same reason as `recordExclusions` and
+ * `selectMatching`: the two builders sit in incompatible hierarchies, so there
+ * is no common base to hold a method. The copies were 94% similar and differed
+ * only in comment wording and braces — no behaviour.
+ *
+ * `phase` is read, never written: recording a misplaced predicate is a
+ * diagnosis, not a state change.
+ */
+export function recordPredicate(predicate, predicates, misplaced, phase) {
+    predicates.push(predicate);
+    // Bug 0155 state 2: a predicate-only method used after `.should()`. Dual-use
+    // methods dispatch to conditions in that phase and never reach here, so this is
+    // a filter written where an assertion was meant — the one state whose fix is
+    // "move it before .should()", not "add a condition".
+    if (phase === 'condition')
+        misplaced.push(predicate.description);
+}
 //# sourceMappingURL=predicate.js.map

package/dist/predicate.js.map

@@ -1 +1 @@
-{"version":3,"file":"predicate.js","sourceRoot":"","sources":["../src/predicate.ts"],"names":[],"mappings":""}
+{"version":3,"file":"predicate.js","sourceRoot":"","sources":["../src/predicate.ts"],"names":[],"mappings":"AA8CA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAC7B,SAAuB,EACvB,UAA0B,EAC1B,SAAmB,EACnB,KAAa;IAEb,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IAC1B,6EAA6E;IAC7E,gFAAgF;IAChF,6EAA6E;IAC7E,qDAAqD;IACrD,IAAI,KAAK,KAAK,WAAW;QAAE,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;AAClE,CAAC"}

package/dist/preset-dispatch.d.ts

@@ -1,4 +1,4 @@
-import type { ArchViolation } from './violation.js';
+import { type CollectResult } from './collect-result.js';
 import type { RuleMetadata } from './rule-metadata.js';
 import { type PresetReportOptions } from './report.js';
 /** Per-rule severity within a preset. */
@@ -15,11 +15,11 @@ export interface PresetBaseOptions extends PresetReportOptions {
  * Anything with `.rule()` and `.violations()` — works with both
  * `RuleBuilder<T, P>` and `TerminalBuilder` hierarchies, across all dialects.
  */
-interface Dispatchable {
+export interface Dispatchable {
     rule(m: RuleMetadata): {
-        violations(): ArchViolation[];
+        violations(): CollectResult;
     };
-    violations(): ArchViolation[];
+    violations(): CollectResult;
 }
 /**
  * Dispatch a single rule within a preset.
@@ -30,19 +30,10 @@ interface Dispatchable {
  */
 export declare function dispatchRule(builder: Dispatchable, rule: string | (RuleMetadata & {
     id: string;
-}), defaultSeverity: RuleSeverity, overrides: Record<string, RuleSeverity> | undefined): ArchViolation[];
+}), defaultSeverity: RuleSeverity, overrides: Record<string, RuleSeverity> | undefined): CollectResult;
 /**
  * Validate override keys against known rule IDs. Warns for unrecognized keys
  * (likely typos).
  */
-export declare function validateOverrides(overrides: Record<string, RuleSeverity> | undefined, knownIds: string[]): void;
-/**
- * Emit (stderr text) and throw a single `ArchRuleError` with all aggregated
- * violations, if any. Kept for backward compatibility; it is now `finishPreset`
- * in the default `throw` mode. New presets take `PresetReportOptions` and call
- * `finishPreset` so a caller can opt into `report: 'return'` / `--format json`
- * (plan 0070).
- */
-export declare function throwIfViolations(violations: ArchViolation[]): void;
-export {};
+export declare function validateOverrides(overrides: Partial<Record<string, RuleSeverity>> | undefined, knownIds: readonly string[]): void;
 //# sourceMappingURL=preset-dispatch.d.ts.map

package/dist/preset-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preset-dispatch.d.ts","sourceRoot":"","sources":["../src/preset-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,OAAO,EAAgB,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEpE,yCAAyC;AACzC,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAA;AAEnD;;;;GAIG;AACH,MAAM,WAAW,iBAAkB,SAAQ,mBAAmB;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACzC;AAED;;;GAGG;AACH,UAAU,YAAY;IACpB,IAAI,CAAC,CAAC,EAAE,YAAY,GAAG;QAAE,UAAU,IAAI,aAAa,EAAE,CAAA;KAAE,CAAA;IACxD,UAAU,IAAI,aAAa,EAAE,CAAA;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,MAAM,GAAG,CAAC,YAAY,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,EAC9C,eAAe,EAAE,YAAY,EAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,GAClD,aAAa,EAAE,CAmBjB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,EACnD,QAAQ,EAAE,MAAM,EAAE,GACjB,IAAI,CAWN;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,IAAI,CAEnE"}
+{"version":3,"file":"preset-dispatch.d.ts","sourceRoot":"","sources":["../src/preset-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,qBAAqB,CAAA;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAGtD,yCAAyC;AACzC,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAA;AAEnD;;;;GAIG;AACH,MAAM,WAAW,iBAAkB,SAAQ,mBAAmB;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACzC;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,CAAC,EAAE,YAAY,GAAG;QAAE,UAAU,IAAI,aAAa,CAAA;KAAE,CAAA;IACtD,UAAU,IAAI,aAAa,CAAA;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,MAAM,GAAG,CAAC,YAAY,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,EAC9C,eAAe,EAAE,YAAY,EAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,GAClD,aAAa,CA2Cf;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAM/B,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,GAAG,SAAS,EAC5D,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,IAAI,CAWN"}

package/dist/preset-dispatch.js

@@ -1,5 +1,7 @@
+import { collectResult } from './collect-result.js';
+import { severityFor } from './violation.js';
 import { formatViolations } from './format.js';
-import { finishPreset } from './report.js';
+import { writeStderr } from './stderr.js';
 /**
  * Dispatch a single rule within a preset.
  *
@@ -14,14 +16,34 @@ export function dispatchRule(builder, rule, defaultSeverity, overrides) {
     // agent`, not just the id.
     const meta = typeof rule === 'string' ? { id: rule } : rule;
     const effective = overrides?.[meta.id] ?? defaultSeverity;
-    if (effective === 'off')
-        return [];
+    if (effective === 'off') {
+        // A real, measured zero — and deliberately NOT `declaredEmpty`.
+        //
+        // ADR-014 §3, amended 2026-09-05: a declaration is one a caller MADE over a
+        // live instrument, never one eess infers from a configuration.
+        // `overrides: { id: 'off' }` is an instruction, and it is byte-identical
+        // whether the author meant "I have scoped this out" or "I turned this off to
+        // stop a finding" — eess is not positioned to tell those apart, so by
+        // ADR-013's rule it must not decide. Marking it declared here would mint,
+        // on the author's behalf, exactly the declaration `declaredEmptyFindings`
+        // refuses to let them write ("'off' deleted the rule, so the declaration
+        // about it is dead").
+        //
+        // The consequence is deliberate: a preset with every rule off sums to zero
+        // examined with no declaration, and the emitter reports it (bug 0261).
+        return collectResult([], { examined: 0, notRun: true });
+    }
     const violations = builder.rule(meta).violations();
     if (effective === 'warn') {
         if (violations.length > 0) {
-            console.warn(formatViolations(violations));
+            writeStderr(formatViolations(violations));
         }
-        return [];
+        // `bypassFilters` outranks a per-rule `overrides: { id: 'warn' }` — see
+        // `severityFor`. A config finding — a zero-examined rule, or a preset that
+        // constructed nothing — is `UNSUPPRESSABLE` by its own text; silently
+        // dropping it here just because its OWN rule was downgraded is exactly the
+        // suppression path that text promises does not exist.
+        return collectResult(violations.filter((v) => severityFor(v, 'warn') === 'error'), { examined: violations.examined });
     }
     return violations;
 }
@@ -29,25 +51,21 @@ export function dispatchRule(builder, rule, defaultSeverity, overrides) {
  * Validate override keys against known rule IDs. Warns for unrecognized keys
  * (likely typos).
  */
-export function validateOverrides(overrides, knownIds) {
+export function validateOverrides(
+// `Partial<Record<...>>` and `readonly`, widened from the narrower shapes this
+// signature had, so `eess-ts`'s byte-identical copy could be deleted rather
+// than kept for its types. Both are strictly more permissive: `Partial` admits
+// an explicit `undefined` value, `readonly` admits a frozen list. No caller
+// loses anything.
+overrides, knownIds) {
     if (!overrides)
         return;
     const knownSet = new Set(knownIds);
     for (const key of Object.keys(overrides)) {
         if (!knownSet.has(key)) {
-            console.warn(`[eess] Override key '${key}' does not match any rule in this preset. ` +
+            writeStderr(`[eess] Override key '${key}' does not match any rule in this preset. ` +
                 `Available rules: ${knownIds.join(', ')}`);
         }
     }
 }
-/**
- * Emit (stderr text) and throw a single `ArchRuleError` with all aggregated
- * violations, if any. Kept for backward compatibility; it is now `finishPreset`
- * in the default `throw` mode. New presets take `PresetReportOptions` and call
- * `finishPreset` so a caller can opt into `report: 'return'` / `--format json`
- * (plan 0070).
- */
-export function throwIfViolations(violations) {
-    finishPreset(violations, { report: 'throw' });
-}
 //# sourceMappingURL=preset-dispatch.js.map

package/dist/preset-dispatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"preset-dispatch.js","sourceRoot":"","sources":["../src/preset-dispatch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,YAAY,EAA4B,MAAM,aAAa,CAAA;AAuBpE;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAqB,EACrB,IAA8C,EAC9C,eAA6B,EAC7B,SAAmD;IAEnD,8EAA8E;IAC9E,gFAAgF;IAChF,6EAA6E;IAC7E,2BAA2B;IAC3B,MAAM,IAAI,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;IAC3D,MAAM,SAAS,GAAG,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,eAAe,CAAA;IACzD,IAAI,SAAS,KAAK,KAAK;QAAE,OAAO,EAAE,CAAA;IAElC,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,CAAA;IAElD,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;QACzB,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAA;QAC5C,CAAC;QACD,OAAO,EAAE,CAAA;IACX,CAAC;IAED,OAAO,UAAU,CAAA;AACnB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAC/B,SAAmD,EACnD,QAAkB;IAElB,IAAI,CAAC,SAAS;QAAE,OAAM;IACtB,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAA;IAClC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QACzC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACvB,OAAO,CAAC,IAAI,CACV,wBAAwB,GAAG,4CAA4C;gBACrE,oBAAoB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC5C,CAAA;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,UAA2B;IAC3D,YAAY,CAAC,UAAU,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAA;AAC/C,CAAC"}
+{"version":3,"file":"preset-dispatch.js","sourceRoot":"","sources":["../src/preset-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAE5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAuBzC;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAqB,EACrB,IAA8C,EAC9C,eAA6B,EAC7B,SAAmD;IAEnD,8EAA8E;IAC9E,gFAAgF;IAChF,6EAA6E;IAC7E,2BAA2B;IAC3B,MAAM,IAAI,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;IAC3D,MAAM,SAAS,GAAG,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,eAAe,CAAA;IACzD,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;QACxB,gEAAgE;QAChE,EAAE;QACF,4EAA4E;QAC5E,+DAA+D;QAC/D,yEAAyE;QACzE,6EAA6E;QAC7E,sEAAsE;QACtE,0EAA0E;QAC1E,0EAA0E;QAC1E,yEAAyE;QACzE,sBAAsB;QACtB,EAAE;QACF,2EAA2E;QAC3E,uEAAuE;QACvE,OAAO,aAAa,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;IACzD,CAAC;IAED,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,CAAA;IAElD,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;QACzB,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,WAAW,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAA;QAC3C,CAAC;QACD,wEAAwE;QACxE,2EAA2E;QAC3E,sEAAsE;QACtE,2EAA2E;QAC3E,sDAAsD;QACtD,OAAO,aAAa,CAClB,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC,EAC5D,EAAE,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAE,CAClC,CAAA;IACH,CAAC;IAED,OAAO,UAAU,CAAA;AACnB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB;AAC/B,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAC/E,4EAA4E;AAC5E,kBAAkB;AAClB,SAA4D,EAC5D,QAA2B;IAE3B,IAAI,CAAC,SAAS;QAAE,OAAM;IACtB,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAA;IAClC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QACzC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACvB,WAAW,CACT,wBAAwB,GAAG,4CAA4C;gBACrE,oBAAoB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC5C,CAAA;QACH,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/project-relative.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Whether a glob can already match an absolute path.
+ *
+ * Extracted from ts-archunit's larger `project-relative.ts`, most of which
+ * (`rootOf`/`relativeToRoot`, workspace multi-root awareness) needs
+ * `ArchProject`/ts-morph and stays deferred — this one predicate is pure
+ * string syntax with no dependency on either, and `glob-diagnosis.ts` needs
+ * it to be kernel-eligible at all, so it gets its own small home here rather
+ * than waiting on the ts-morph-blocked half of the file it came from.
+ *
+ * Covers POSIX-absolute and Windows drive-absolute globs as well as an
+ * explicit globstar.
+ */
+export declare function isAnchored(glob: string): boolean;
+/**
+ * Does this glob name a location relative to the project root?
+ *
+ * Only an **unanchored, relative** glob is normalized. `'**\/x'` is explicitly
+ * "anywhere" and must keep meaning that; `'/abs/x'` is already absolute. So
+ * this is the same population `syntacticFault` calls `unanchored`, which is
+ * what makes the two consistent: a glob stops being reported dead for being
+ * unanchored exactly when it starts working.
+ */
+export declare function isProjectRelative(glob: string): boolean;
+//# sourceMappingURL=project-relative.d.ts.map

package/dist/project-relative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-relative.d.ts","sourceRoot":"","sources":["../src/project-relative.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAyBvD"}

package/dist/project-relative.js

@@ -0,0 +1,54 @@
+/**
+ * Whether a glob can already match an absolute path.
+ *
+ * Extracted from ts-archunit's larger `project-relative.ts`, most of which
+ * (`rootOf`/`relativeToRoot`, workspace multi-root awareness) needs
+ * `ArchProject`/ts-morph and stays deferred — this one predicate is pure
+ * string syntax with no dependency on either, and `glob-diagnosis.ts` needs
+ * it to be kernel-eligible at all, so it gets its own small home here rather
+ * than waiting on the ts-morph-blocked half of the file it came from.
+ *
+ * Covers POSIX-absolute and Windows drive-absolute globs as well as an
+ * explicit globstar.
+ */
+export function isAnchored(glob) {
+    return glob.startsWith('**/') || glob.startsWith('/') || /^[A-Za-z]:\//.test(glob);
+}
+/**
+ * Does this glob name a location relative to the project root?
+ *
+ * Only an **unanchored, relative** glob is normalized. `'**\/x'` is explicitly
+ * "anywhere" and must keep meaning that; `'/abs/x'` is already absolute. So
+ * this is the same population `syntacticFault` calls `unanchored`, which is
+ * what makes the two consistent: a glob stops being reported dead for being
+ * unanchored exactly when it starts working.
+ */
+export function isProjectRelative(glob) {
+    // A `./` segment is excluded, and that exclusion is load-bearing rather than
+    // fussy. `syntacticFault` reports `dot-segment` for a `./` anywhere in a
+    // glob, so normalizing one would make the rule MATCH at runtime while the
+    // gate still reported it dead — two derivations disagreeing about the same
+    // glob, which is the failure this project spends most of its guards on.
+    //
+    // `./` is a mistake in both worlds — it never occurs in an absolute path and
+    // it says nothing extra in a relative one — so the honest fix is to leave it
+    // failing, with advice that says to remove it.
+    // `..` is not relative-to-the-root in any usable sense: containment returns
+    // `undefined` for anything above the root, deliberately, so a `../`
+    // glob would normalize to nothing and be reported dead with three false
+    // causes. Excluded alongside `./` — both are mistakes in both readings.
+    if (/(?:^|\/)\.\.?\//.test(glob))
+        return false;
+    // Derived from `isAnchored`, not restated — two lists that disagree is the
+    // failure this file spends most of its guards on. `isAnchored` covers `/x`,
+    // `**/x` and a drive-absolute `C:/x`.
+    if (isAnchored(glob))
+        return false;
+    // `*/x/**` is deliberately NOT normalized, even though it is unanchored.
+    // Normalizing it would make it match, which sounds like an improvement until
+    // you notice it is the LAST reachable `unanchored` fault for a path glob —
+    // the anchor advice would become unreachable. Left failing, with a remedy
+    // that works: `'**/x/**'`.
+    return !glob.startsWith('*/');
+}
+//# sourceMappingURL=project-relative.js.map

package/dist/project-relative.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-relative.js","sourceRoot":"","sources":["../src/project-relative.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACpF,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,6EAA6E;IAC7E,yEAAyE;IACzE,0EAA0E;IAC1E,2EAA2E;IAC3E,wEAAwE;IACxE,EAAE;IACF,6EAA6E;IAC7E,6EAA6E;IAC7E,+CAA+C;IAC/C,4EAA4E;IAC5E,oEAAoE;IACpE,wEAAwE;IACxE,wEAAwE;IACxE,IAAI,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAA;IAC9C,2EAA2E;IAC3E,4EAA4E;IAC5E,sCAAsC;IACtC,IAAI,UAAU,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAA;IAClC,yEAAyE;IACzE,6EAA6E;IAC7E,2EAA2E;IAC3E,0EAA0E;IAC1E,2BAA2B;IAC3B,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;AAC/B,CAAC"}

package/dist/report.d.ts

@@ -1,4 +1,4 @@
-import type { ArchViolation } from './violation.js';
+import { type CollectResult } from './collect-result.js';
 import type { OutputFormat } from './check-options.js';
 /**
  * How a preset delivers its violations (plan 0070, ADR-008):
@@ -18,21 +18,51 @@ export interface ReportOptions {
 export interface PresetReportOptions extends ReportOptions {
     /** Delivery mode. Default `throw`. */
     readonly report?: ReportMode;
+    /**
+     * Declare that this preset's subject legitimately does not exist here —
+     * [ADR-010](../../../adr/010-a-pass-is-constructed-from-evidence.md) §3.
+     *
+     * **On the shared options type, not on six preset interfaces**, because
+     * ADR-010 §3's second clause is about presets as a class: "A preset user does
+     * not hold the builder; if a preset option cannot carry the user's
+     * empty-declaration to the mint, their only reachable remedy is disabling the
+     * option — deleting coverage permanently (ADR-009 rule 1's trained-suppression
+     * dynamic, reproduced by this ADR's own gate if unaddressed)." A preset that
+     * examines nothing and cannot be told so leaves its user exactly one exit, and
+     * it is the wrong one.
+     *
+     * **It expires**, which is the only reason it is admissible at all: declare
+     * this and then examine something, and the emitter reports
+     * `emitter/expired-declaration`. A claim nothing can contradict is not an
+     * assertion — the property ADR-014 §3's 2026-09-05 amendment turns on when it
+     * refuses to infer a declaration from `overrides: 'off'`.
+     *
+     * Use it for a corpus with no ER diagrams, a suite with no exemptions, a
+     * project that genuinely has none of this preset's subject. Do not use it to
+     * quiet a preset whose glob is wrong: the day the glob is fixed, this reddens.
+     */
+    readonly expectEmpty?: boolean;
 }
 /**
- * The single place that knows how to *emit* violations — text (stderr), JSON,
- * or GitHub annotations (stdout). No throw, no filtering, no control flow: just
- * emission. `executeCheck` (the `.check()` path) and `finishPreset` (the preset
- * path) both delegate here, so the two reporting paths can no longer diverge
- * (plan 0070). Emits nothing for an empty set.
+ * How many violations this module has actually WRITTEN, ever.
+ *
+ * Read as a delta by a caller that aggregates reporting, to answer one question it
+ * cannot otherwise answer: *did something emit while I was loading that module?*
+ *
+ * The alternative a caller might reach for — counting the writes it SUPPRESSED and
+ * inferring "then nothing was written" — is a double negative and is unsound: a
+ * module that suppresses one terminal and leaks through another satisfies it while
+ * leaking. Measured on `eess-ts`, which shipped that inference and fell into
+ * exactly that case. Count emissions, not silences.
  */
-export declare function reportViolations(violations: ArchViolation[], options?: ReportOptions): void;
+export declare function violationsEmittedCount(): number;
+export declare function reportViolations(violations: CollectResult, options?: ReportOptions): CollectResult;
 /**
  * Finish a preset: deliver its aggregated violations per the requested mode
- * (plan 0070). `throw` (default) emits then throws — backward-compatible with
- * `throwIfViolations`; `return` hands the violations back untouched (the caller
- * owns emission and control flow); `warn` emits without throwing. Always
- * returns the violations, so a caller can inspect them regardless of mode.
+ * (plan 0070). `throw` (default) emits then throws; `return` hands the
+ * violations back untouched (the caller owns emission and control flow);
+ * `warn` emits without throwing. Always returns the violations, so a caller can
+ * inspect them regardless of mode.
  */
-export declare function finishPreset(violations: ArchViolation[], options?: PresetReportOptions): ArchViolation[];
+export declare function finishPreset(violations: CollectResult, options?: PresetReportOptions): CollectResult;
 //# sourceMappingURL=report.d.ts.map

package/dist/report.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAMtD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEpD,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAA;IAC9B,kDAAkD;IAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,sEAAsE;AACtE,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD,sCAAsC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAA;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,aAAa,EAAE,EAAE,OAAO,GAAE,aAAkB,GAAG,IAAI,CAY/F;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,EAAE,EAC3B,OAAO,GAAE,mBAAwB,GAChC,aAAa,EAAE,CAQjB"}
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAA8B,MAAM,qBAAqB,CAAA;AAUpF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAMtD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEpD,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAA;IAC9B,kDAAkD;IAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,sEAAsE;AACtE,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD,sCAAsC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAA;IAE5B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAC/B;AAWD;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AA6HD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,aAAa,EACzB,OAAO,GAAE,aAAkB,GAC1B,aAAa,CAqBf;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,EACzB,OAAO,GAAE,mBAAwB,GAChC,aAAa,CAoCf"}