@nielspeter/eess-ts 0.2.0 → 0.4.0

package/dist/core/object-literal-functions.js

@@ -0,0 +1,75 @@
+/**
+ * Object-literal function traversal. **In `core/` because it was the wrong way up.**
+ *
+ * It lived in `helpers/` and was imported by `models/arch-function.ts` — a
+ * `models → helpers` edge, which is backwards: helpers may depend on models, not
+ * the reverse. That edge sat harmlessly until
+ * [ts-archunit plan 0082](https://github.com/nielspeter/ts-archunit/blob/main/plans/completed/0082-an-object-literal-callback-keeps-its-name.md)
+ * added `helpers/callback-extractor.ts → models/arch-function.ts` as a **value**
+ * import, closing a runtime cycle.
+ *
+ * Measured: at v0.45.6 no file in `helpers/` had a value import from `models/` —
+ * only `import type`. So the cycle was one day old when
+ * [ts-archunit plan 0084](https://github.com/nielspeter/ts-archunit/blob/main/plans/completed/0084-cycle-detection-that-ignores-type-only-imports.md)
+ * found it, and the rule that exists to catch exactly this was pinned at `.warn()`
+ * with a comment explaining why. A rule that cannot fail let a cycle in overnight.
+ *
+ * This module imports nothing but ts-morph, so `core/` costs it no dependency and
+ * both `models → core` and `helpers → core` are permitted directions.
+ */
+import { Node } from 'ts-morph';
+/** Default recursion depth into nested object literals (matches the callback path). */
+const MAX_OBJECT_LITERAL_DEPTH = 3;
+/**
+ * Walk an object literal and collect every function-valued property — arrow,
+ * function expression, or method shorthand — recursing into nested object
+ * literals up to `maxDepth`. Call-agnostic (F3): the single traversal shared by
+ * `functions()` object-literal collection (proposal 016) and the
+ * callback-extractor (`within()` / call path), so the two cannot drift.
+ *
+ * Only descends into nested object-literal property values, never into function
+ * bodies. Returns `[]` when `node` is not an object literal.
+ */
+export function collectObjectLiteralFunctions(node, maxDepth = MAX_OBJECT_LITERAL_DEPTH) {
+    const out = [];
+    walk(node, [], 0, maxDepth, out);
+    return out;
+}
+function walk(node, keyPath, depth, maxDepth, out) {
+    if (!Node.isObjectLiteralExpression(node))
+        return;
+    if (depth >= maxDepth)
+        return;
+    for (const prop of node.getProperties()) {
+        // Method shorthand: { GET(req) { ... } }
+        if (Node.isMethodDeclaration(prop)) {
+            out.push({ node: prop, keyPath: [...keyPath, keyOf(prop)] });
+            continue;
+        }
+        if (!Node.isPropertyAssignment(prop))
+            continue;
+        const init = prop.getInitializer();
+        if (!init)
+            continue;
+        const key = keyOf(prop);
+        // Arrow / function-expression property value.
+        if (Node.isArrowFunction(init) || Node.isFunctionExpression(init)) {
+            out.push({ node: init, keyPath: [...keyPath, key] });
+            continue;
+        }
+        // Nested object literal — recurse (depth-limited).
+        if (Node.isObjectLiteralExpression(init)) {
+            walk(init, [...keyPath, key], depth + 1, maxDepth, out);
+        }
+    }
+}
+/** Property key as a string; computed keys degrade to a defined `<computed>` sentinel. */
+function keyOf(prop) {
+    const nameNode = prop.getNameNode();
+    if (Node.isComputedPropertyName(nameNode))
+        return '<computed>';
+    if (Node.isStringLiteral(nameNode))
+        return nameNode.getLiteralValue();
+    return nameNode.getText();
+}
+//# sourceMappingURL=object-literal-functions.js.map

package/dist/core/object-literal-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-literal-functions.js","sourceRoot":"","sources":["../../src/core/object-literal-functions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAe/B,uFAAuF;AACvF,MAAM,wBAAwB,GAAG,CAAC,CAAA;AAElC;;;;;;;;;GASG;AACH,MAAM,UAAU,6BAA6B,CAC3C,IAAU,EACV,WAAmB,wBAAwB;IAE3C,MAAM,GAAG,GAA4B,EAAE,CAAA;IACvC,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAA;IAChC,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,SAAS,IAAI,CACX,IAAU,EACV,OAA0B,EAC1B,KAAa,EACb,QAAgB,EAChB,GAA4B;IAE5B,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC;QAAE,OAAM;IACjD,IAAI,KAAK,IAAI,QAAQ;QAAE,OAAM;IAE7B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;QACxC,yCAAyC;QACzC,IAAI,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;YACnC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAA;YAC5D,SAAQ;QACV,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC;YAAE,SAAQ;QAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QAClC,IAAI,CAAC,IAAI;YAAE,SAAQ;QACnB,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,CAAA;QACvB,8CAA8C;QAC9C,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;YAClE,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC,CAAA;YACpD,SAAQ;QACV,CAAC;QACD,mDAAmD;QACnD,IAAI,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAA;QACzD,CAAC;IACH,CAAC;AACH,CAAC;AAED,0FAA0F;AAC1F,SAAS,KAAK,CAAC,IAA4C;IACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,CAAA;IACnC,IAAI,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC;QAAE,OAAO,YAAY,CAAA;IAC9D,IAAI,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC;QAAE,OAAO,QAAQ,CAAC,eAAe,EAAE,CAAA;IACrE,OAAO,QAAQ,CAAC,OAAO,EAAE,CAAA;AAC3B,CAAC"}

package/dist/core/orphan-exclusions.d.ts

@@ -0,0 +1,44 @@
+import type { DiagnosableRule } from './diagnose.js';
+/**
+ * How much of the project the caller actually looked at.
+ *
+ * `orphanExclusions` compares directives against the ids of the rules it is
+ * handed. If that is a **subset** of the project's rules, a directive naming a
+ * rule declared elsewhere looks orphaned — so a caller that knows it saw only
+ * part of the project says so, and the advice carries the caveat.
+ */
+interface OrphanExclusionOptions {
+    /** Rule files inspected, when the caller counted them. */
+    readonly ruleFilesChecked?: number;
+    /** Rule files the caller believes exist, when it knows. */
+    readonly ruleFilesTotal?: number;
+    /**
+     * Called once per source file, with whether that file was parsed.
+     *
+     * Exists so a test can assert the cheap reject still applies. Deleting that
+     * `continue` changes **cost and not behaviour**, so every functional test stays
+     * green — which is how a 3.0x regression could ship unnoticed, and how two
+     * separate attempts to measure it could both land on the wrong arm.
+     */
+    readonly onFileScanned?: (parsed: boolean) => void;
+}
+/** One exclusion comment naming a rule id nothing declares. */
+export interface OrphanExclusion {
+    /** The rule id the comment names. */
+    readonly ruleId: string;
+    /** The source file holding the comment. */
+    readonly file: string;
+    /** The comment's line. */
+    readonly line: number;
+    /** The sanctioned fix. */
+    readonly advice: string;
+}
+/**
+ * Every exclusion comment in the project naming a rule id no rule declares.
+ *
+ * @param rules - **All** rules, across every rule file. A subset yields false
+ *   orphans; see the module docstring.
+ */
+export declare function orphanExclusions(rules: readonly DiagnosableRule[], options?: OrphanExclusionOptions): OrphanExclusion[];
+export {};
+//# sourceMappingURL=orphan-exclusions.d.ts.map

package/dist/core/orphan-exclusions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orphan-exclusions.d.ts","sourceRoot":"","sources":["../../src/core/orphan-exclusions.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD;;;;;;;GAOG;AACH,UAAU,sBAAsB;IAC9B,0DAA0D;IAC1D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAClC,2DAA2D;IAC3D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;CACnD;AAgBD,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,0BAA0B;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAoCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,eAAe,EAAE,CAwHnB"}

package/dist/core/orphan-exclusions.js

@@ -0,0 +1,214 @@
+/**
+ * Exclusion comments that name a rule nobody declares —
+ * [ts-archunit bug 0044](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0044-an-inline-exclusion-comment-has-no-feedback-channel.md).
+ *
+ * `.excluding()` warns when a pattern matches zero violations. An inline
+ * `// eess-exclude` comment has no equivalent, and **cannot get one on the
+ * enforcement path**: comments are parsed only in files that already produced a
+ * violation (`execute-rule.ts`'s `result.length > 0` gate), so a directive naming
+ * a rule id that no longer exists is never even read. Rename a rule and every
+ * comment naming the old id goes inert — silently, permanently.
+ *
+ * That is the failure v0.37.0's suppression disclosure does **not** cover. That
+ * reports what a comment *did* silence; this reports a comment that silences
+ * nothing.
+ *
+ * ## Why a diagnostic and not a finding
+ *
+ * [ADR-009](../../../../adr/009-agent-first-failure-surfaces.md) rule 1's migration
+ * corollary: *"a warning is something you hope is read; a command is something
+ * someone ran."* This cannot be a check-time finding without parsing every file
+ * in scope on every run — the cost the `result.length > 0` gate exists to avoid —
+ * so it goes where `doctor` already looks.
+ *
+ * ## It must see EVERY rule, and that is a real footgun
+ *
+ * The declared-id set is the union across all rule files. `doctor` diagnoses one
+ * file at a time (`cli/commands/doctor.ts`), and a directive naming a rule
+ * declared in a *different* file would be reported as an orphan if this were
+ * called per file. So it is deliberately **not** part of `diagnose()`: it takes
+ * every rule at once, and calling it with a subset produces false orphans.
+ *
+ * Same shape as `checkAll` versus a per-rule `.check()`, which this project
+ * already documents: some facts are only true at the run boundary.
+ *
+ * ## What it does not catch
+ *
+ * A directive whose rule id is **correct** but whose placement is wrong — the
+ * other half of bug 0044. Catching that needs the enforcement path to know which
+ * violations a comment failed to cover, which is option 1 in that bug and costs a
+ * parse per file per rule. Stated here rather than left to be discovered.
+ */
+import { parseExclusionComments } from './exclusion-comments.js';
+/** The caveat, or `''` when the caller vouched for full coverage. */
+function scopeNote(options) {
+    const checked = options?.ruleFilesChecked;
+    if (checked === undefined)
+        return '';
+    const total = options?.ruleFilesTotal;
+    if (total !== undefined && checked >= total)
+        return '';
+    const files = checked === 1 ? 'file' : 'files';
+    return (`Checked against ${String(checked)} rule ${files} only — if this id is declared in a rule ` +
+        `file that was not inspected, this report is a false positive and the comment is working. ` +
+        `Pass every rule file to be sure. `);
+}
+/**
+ * Could this text hold a directive at all?
+ *
+ * One predicate, two callers — and the deduplication is the point. This test
+ * existed as two identical inline `includes` checks, and that duplication caused
+ * a real measurement error: an attempt to time the cost of removing it patched
+ * the wrong occurrence, so both arms ran the same path and the saving looked
+ * imaginary. Two identical lines where only one is guarded is a trap for
+ * whoever sabotages next, so there is now one line to remove.
+ *
+ * Sound because `parseExclusionComments` only ever *removes* directives when
+ * blanking literals (bug 0043) — it cannot invent one in a file that does not
+ * contain the text.
+ */
+function mayHoldDirective(text) {
+    return text.includes('eess-exclude');
+}
+/** The first directive found anywhere, so the aggregate finding has a location. */
+function firstDirective(projects) {
+    for (const project of projects) {
+        for (const sourceFile of project.getSourceFiles()) {
+            const text = sourceFile.getFullText();
+            if (!mayHoldDirective(text))
+                continue;
+            const path = sourceFile.getFilePath();
+            const [first] = parseExclusionComments(text, path).exclusions;
+            if (first !== undefined)
+                return { file: path, line: first.line };
+        }
+    }
+    return undefined;
+}
+/**
+ * Every exclusion comment in the project naming a rule id no rule declares.
+ *
+ * @param rules - **All** rules, across every rule file. A subset yields false
+ *   orphans; see the module docstring.
+ */
+export function orphanExclusions(rules, options) {
+    const declared = new Set();
+    const projects = [];
+    for (const rule of rules) {
+        const id = rule.describeRule?.().id;
+        if (id !== undefined && id !== '')
+            declared.add(id);
+        const project = rule.getProject?.();
+        // By object, not by `tsConfigPath` — that path is not an identity, per
+        // `diagnose()`'s own reasoning (bug 0011's class).
+        //
+        // Note what this does NOT guard against, because the first comment here got
+        // it wrong: `workspace([a, b])` builds a **single** ts-morph project and
+        // returns one `ArchProject`, so it contributes one entry either way.
+        // Measured. The case that needs deduping is two separate `project()` calls
+        // whose globs overlap — and that is what `seen` below is for.
+        if (project !== undefined && !projects.includes(project))
+            projects.push(project);
+    }
+    // Nothing declares an id — so every inline exclusion in this project really IS
+    // inert (`isExcludedByComment` returns false without a `ruleId`, and the scan
+    // is gated on `ctx.metadata?.id`). Reporting nothing was the first behaviour
+    // and it was wrong in the ADR-009 rule 1 direction: those are all real
+    // orphans, and the diagnostic was silent about every one of them.
+    //
+    // Reporting each of them is the other failure — a wall of findings for one
+    // authored cause, which is what rule 4 calls a total standing in for an
+    // identity. So: **one** aggregate finding naming the cause, which is neither
+    // noise nor silence.
+    if (declared.size === 0) {
+        const anyDirective = firstDirective(projects);
+        if (anyDirective === undefined)
+            return [];
+        return [
+            {
+                ruleId: '(none declared)',
+                file: anyDirective.file,
+                line: anyDirective.line,
+                advice: `No rule declares an id, so **every** inline \`// eess-exclude\` comment in ` +
+                    `this project is inert — a comment can only match a rule that carries ` +
+                    `\`.rule({ id })\`. Add ids to the rules these comments name, or delete the ` +
+                    `comments. Reported once rather than per comment: one cause, one finding.`,
+            },
+        ];
+    }
+    const found = [];
+    const seen = new Set();
+    for (const project of projects) {
+        for (const sourceFile of project.getSourceFiles()) {
+            const path = sourceFile.getFilePath();
+            // `getFullText()`, not `fs.readFileSync`. The text is already in memory, so
+            // the read was a second I/O that also **silently lost findings**: review
+            // measured an in-memory project's stale directive vanishing (ENOENT into
+            // the catch) and a `chmod 000` file doing the same with nothing on stderr.
+            // A diagnostic whose entire subject is "this silently does nothing" must
+            // not silently do nothing. The catch is gone because its cause is gone.
+            const text = sourceFile.getFullText();
+            // Cheap reject before the parse, load-bearing on soundness AND on cost.
+            //
+            // Sound because `parseExclusionComments` only ever *removes* directives
+            // when blanking literals (bug 0043), so a file with no occurrence of the
+            // literal text cannot hold one.
+            //
+            // The cost shape is the better argument: it scales with **directive-bearing
+            // files, not project size** — ~5.7ms per parsed file, against ~2.6ms times
+            // *every* file without it. This repository has 18 of 566 files mentioning
+            // the literal (mostly its own source discussing the feature), so the pass
+            // costs ~105ms instead of ~1.5s and `doctor` ~670ms instead of ~2.0s. A
+            // 5000-file consumer monorepo with **no** directives would have paid ~13s
+            // per run to report nothing.
+            //
+            // I measured this as ~1.0x and concluded the saving was imaginary. Wrong
+            // twice: the first attempt was vacuous (`findings=0`, equally consistent
+            // with scanning nothing), and the second patched the **other** occurrence
+            // of this line — `firstDirective` above carries the same reject — so both
+            // arms ran the same path. Removing a `continue` changes cost and not
+            // behaviour, so no output distinguished them, and 18 parses cost the same
+            // ~105ms either way. `onFileScanned` exists because counting is the only
+            // way to assert this reject still applies.
+            if (!mayHoldDirective(text)) {
+                options?.onFileScanned?.(false);
+                continue;
+            }
+            options?.onFileScanned?.(true);
+            for (const comment of parseExclusionComments(text, path).exclusions) {
+                if (declared.has(comment.ruleId))
+                    continue;
+                // One report per (id, file, line): a block directive naming two rules
+                // yields two comments, and the same file can be reached through two
+                // projects in a workspace.
+                const key = `${comment.ruleId} ${path} ${String(comment.line)}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                found.push({
+                    ruleId: comment.ruleId,
+                    file: path,
+                    line: comment.line,
+                    // The scope caveat is FIRST, and it is not decoration.
+                    //
+                    // Review measured the false positive this module's docstring claims to
+                    // prevent, reachable through the documented CLI form: `doctor
+                    // a.rules.ts` on a project whose comment names a rule declared in
+                    // `b.rules.ts` reported that working comment as an orphan — and then
+                    // told the reader to **delete it**, which un-waives a real violation.
+                    // A remedy that is wrong on the path that produced it is worse than
+                    // none (ADR-009 rule 2), so the caller states its scope and the reader
+                    // is told what it means.
+                    advice: `${scopeNote(options)}This exclusion names '${comment.ruleId}', which no rule ` +
+                        `declares — so it suppresses nothing and the rule it was meant to waive is being ` +
+                        `enforced here. Either correct the id to a rule that exists, or delete the ` +
+                        `comment. The commonest cause is a rule that was renamed: nothing reports this at ` +
+                        `check time, because a comment is only read in a file that already produced a ` +
+                        `finding for that rule.`,
+                });
+            }
+        }
+    }
+    return found;
+}
+//# sourceMappingURL=orphan-exclusions.js.map

package/dist/core/orphan-exclusions.js.map

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

package/dist/core/pair-condition.d.ts

@@ -1,10 +1,39 @@
 import type { SourceFile } from 'ts-morph';
-import type { ArchViolation } from './violation.js';
+import type { ArchViolation } from '@nielspeter/eess';
 import type { ConditionContext } from '@nielspeter/eess';
-import type { LayerPair } from '../models/cross-layer.js';
+import type { LayerPair, Layer } from '../models/cross-layer.js';
+/**
+ * What a pair condition is given, beyond an ordinary condition's context.
+ *
+ * `layers` is the builder's **own resolved** layers —
+ * [ts-archunit bug 0040](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0040-a-crosslayer-rule-reports-nothing-when-its-layer-resolves-nothing.md).
+ * Before this, `haveMatchingCounterpart` took a `Layer[]` argument that **no
+ * public API could produce**: `PairFinalBuilder.layers` is private at every
+ * stage and `resolveLayer` is unexported, so every caller hand-built the array
+ * and the condition judged that copy rather than the builder's resolution.
+ * Measured: builder glob dead, hand-built layers populated → two counterpart
+ * violations and no configuration finding, describing an array the library never
+ * resolved.
+ *
+ * ## Why a subtype rather than a field on `ConditionContext`
+ *
+ * A pair-only field on the base context leaks onto every class, function, module
+ * and type condition. `identifyByArgument` is the one precedent, and its own
+ * docstring justifies itself as "one optional primitive" — a second would make
+ * that comment false.
+ *
+ * This is still additive for an external implementer: TypeScript method
+ * parameters are bivariant, so a condition declaring `ConditionContext` still
+ * satisfies `PairCondition`. Verified — `haveConsistentExports` and
+ * `satisfyPairCondition` compile unchanged.
+ */
+export interface PairConditionContext extends ConditionContext {
+    /** The layers the builder resolved, in declaration order. */
+    readonly layers: readonly Layer[];
+}
 /** Condition that evaluates matched pairs from two layers. */
 export interface PairCondition<A = SourceFile, B = SourceFile> {
     readonly description: string;
-    evaluate(pairs: LayerPair<A, B>[], context: ConditionContext): ArchViolation[];
+    evaluate(pairs: LayerPair<A, B>[], context: PairConditionContext): ArchViolation[];
 }
 //# sourceMappingURL=pair-condition.d.ts.map

package/dist/core/pair-condition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pair-condition.d.ts","sourceRoot":"","sources":["../../src/core/pair-condition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAEzD,8DAA8D;AAC9D,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,UAAU;IAC3D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,gBAAgB,GAAG,aAAa,EAAE,CAAA;CAC/E"}
+{"version":3,"file":"pair-condition.d.ts","sourceRoot":"","sources":["../../src/core/pair-condition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB;IAC5D,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAA;CAClC;AAED,8DAA8D;AAC9D,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,UAAU;IAC3D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,oBAAoB,GAAG,aAAa,EAAE,CAAA;CACnF"}

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

@@ -0,0 +1,54 @@
+import type { ArchProject } from './project.js';
+/**
+ * Every path a glob could legitimately match in a project, materialized once.
+ *
+ * A free function over `ArchProject` rather than a method on it: bare-object
+ * `ArchProject` literals are real test doubles across the suite, and adding a
+ * required method would break every one of them. Lives in `src/core/`, takes
+ * `ArchProject` in and hands plain strings out, and imports no ts-morph —
+ * ADR-007's batch-first shape by construction, one materialization instead of
+ * a traversal per glob.
+ */
+export interface PathUniverse {
+    /** Absolute paths of every file in the project. */
+    readonly filePaths: readonly string[];
+    /**
+     * Immediate parent directories only.
+     *
+     * Not all ancestors. `resideInFolder` 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**: measured on this repo, 41 of
+     * the 122 ancestors are no file's parent, so `resideInFolder('**\/tests/fixtures')`
+     * can never select anything while an all-ancestors universe calls it
+     * satisfiable. Using the parent set removes the over-approximation rather
+     * than excusing it.
+     */
+    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 project's path universe, computed once per project.
+ *
+ * Memoized on the project identity, so a rule file with fifty rules pays for
+ * one traversal rather than fifty.
+ */
+export declare function pathUniverse(project: ArchProject): PathUniverse;
+/**
+ * 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. It does NOT make `base`
+ * message-only: the anchor check in `syntacticFault` consults it, 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/core/path-universe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-universe.d.ts","sourceRoot":"","sources":["../../src/core/path-universe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC;;;;;;;;;;;OAWG;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;AAID;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,YAAY,CAiB/D;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/core/path-universe.js

@@ -0,0 +1,65 @@
+const cache = new WeakMap();
+/**
+ * The project's path universe, computed once per project.
+ *
+ * Memoized on the project identity, so a rule file with fifty rules pays for
+ * one traversal rather than fifty.
+ */
+export function pathUniverse(project) {
+    const cached = cache.get(project);
+    if (cached)
+        return cached;
+    const filePaths = project.getSourceFiles().map((sourceFile) => sourceFile.getFilePath());
+    const parentDirs = [
+        ...new Set(filePaths.map((filePath) => filePath.substring(0, filePath.lastIndexOf('/')))),
+    ];
+    const root = tsconfigDir(project.tsConfigPath);
+    const universe = {
+        filePaths,
+        parentDirs,
+        tsconfigRelativeFilePaths: filePaths.map((filePath) => relativeTo(root, filePath)),
+        tsconfigRelativeParentDirs: parentDirs.map((dir) => relativeTo(root, dir)),
+    };
+    cache.set(project, universe);
+    return universe;
+}
+/**
+ * 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. It does NOT make `base`
+ * message-only: the anchor check in `syntacticFault` consults it, 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 [];
+}
+/** The directory containing the tsconfig, with forward slashes and no trailing separator. */
+function tsconfigDir(tsConfigPath) {
+    const normalized = tsConfigPath.replaceAll('\\', '/');
+    const lastSlash = normalized.lastIndexOf('/');
+    return lastSlash === -1 ? '' : normalized.slice(0, lastSlash);
+}
+/**
+ * `filePath` relative to `root`, or unchanged when it sits outside.
+ *
+ * Deliberately not `path.relative`: that would emit `../../..` for a path
+ * above the root, which encodes the root's depth — machine-dependent, and the
+ * same mistake `toPortablePath` exists to avoid.
+ */
+function relativeTo(root, filePath) {
+    if (root === '')
+        return filePath;
+    const prefix = root.endsWith('/') ? root : root + '/';
+    return filePath.startsWith(prefix) ? filePath.slice(prefix.length) : filePath;
+}
+//# sourceMappingURL=path-universe.js.map

package/dist/core/path-universe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-universe.js","sourceRoot":"","sources":["../../src/core/path-universe.ts"],"names":[],"mappings":"AAkCA,MAAM,KAAK,GAAG,IAAI,OAAO,EAA6B,CAAA;AAEtD;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,OAAoB;IAC/C,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IACjC,IAAI,MAAM;QAAE,OAAO,MAAM,CAAA;IAEzB,MAAM,SAAS,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAA;IACxF,MAAM,UAAU,GAAG;QACjB,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC1F,CAAA;IACD,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,CAAA;IAC9C,MAAM,QAAQ,GAAiB;QAC7B,SAAS;QACT,UAAU;QACV,yBAAyB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAClF,0BAA0B,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;KAC3E,CAAA;IACD,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC5B,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED;;;;;;;;;;;;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;AAED,6FAA6F;AAC7F,SAAS,WAAW,CAAC,YAAoB;IACvC,MAAM,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IACrD,MAAM,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;IAC7C,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;AAC/D,CAAC;AAED;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,IAAY,EAAE,QAAgB;IAChD,IAAI,IAAI,KAAK,EAAE;QAAE,OAAO,QAAQ,CAAA;IAChC,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAA;IACrD,OAAO,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAA;AAC/E,CAAC"}

package/dist/core/per-root-compiler-options.d.ts

@@ -0,0 +1,20 @@
+import { Project as TsMorphProject } from 'ts-morph';
+import type { SourceFile } from 'ts-morph';
+/**
+ * Record each config's options against the root directory it governs.
+ *
+ * Called by `workspace()` with every resolved tsconfig path — **every** one, not just the
+ * primary, which is the whole point. `project()` does not need it: one config governs one
+ * project, so the project-wide lookup is already correct there.
+ */
+export declare function registerRootCompilerOptions(tsMorphProject: TsMorphProject, tsConfigPaths: readonly string[]): void;
+/**
+ * `verbatimModuleSyntax` for the package that owns this file.
+ *
+ * Falls back to the project-wide value, which is correct for `project()` and for any
+ * project built without going through `workspace()` — an in-memory test double, for
+ * instance. The fallback is the OLD behaviour, so a file the registry does not cover
+ * answers exactly as it did before bug 0058.
+ */
+export declare function verbatimModuleSyntaxFor(sourceFile: SourceFile): boolean;
+//# sourceMappingURL=per-root-compiler-options.d.ts.map

package/dist/core/per-root-compiler-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"per-root-compiler-options.d.ts","sourceRoot":"","sources":["../../src/core/per-root-compiler-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,UAAU,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAiD1C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,cAAc,EAC9B,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B,IAAI,CAQN;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAUvE"}

package/dist/core/per-root-compiler-options.js

@@ -0,0 +1,57 @@
+import { Project as TsMorphProject } from 'ts-morph';
+import { rootOf } from './project-relative.js';
+const optionsByProject = new WeakMap();
+/**
+ * Read one tsconfig's options **without loading its files**.
+ *
+ * `skipAddingFilesFromTsConfig` is the load-bearing part: a `workspace()` of ten packages
+ * would otherwise parse every package's sources ten times over to answer one boolean.
+ * Going through ts-morph rather than reading the JSON is also deliberate — `extends` has
+ * to resolve, and hand-rolling that is how a monorepo whose packages inherit a base
+ * config gets the wrong answer (ADR-002: ts-morph owns this).
+ */
+function readRootOptions(tsConfigPath) {
+    const parsed = new TsMorphProject({
+        tsConfigFilePath: tsConfigPath,
+        skipAddingFilesFromTsConfig: true,
+    });
+    return { verbatimModuleSyntax: parsed.getCompilerOptions().verbatimModuleSyntax === true };
+}
+/**
+ * Record each config's options against the root directory it governs.
+ *
+ * Called by `workspace()` with every resolved tsconfig path — **every** one, not just the
+ * primary, which is the whole point. `project()` does not need it: one config governs one
+ * project, so the project-wide lookup is already correct there.
+ */
+export function registerRootCompilerOptions(tsMorphProject, tsConfigPaths) {
+    const byRoot = new Map();
+    for (const configPath of tsConfigPaths) {
+        const normalized = configPath.replaceAll('\\', '/');
+        const root = normalized.replace(/\/[^/]*$/, '') || '/';
+        byRoot.set(root, readRootOptions(configPath));
+    }
+    if (byRoot.size > 0)
+        optionsByProject.set(tsMorphProject, byRoot);
+}
+/**
+ * `verbatimModuleSyntax` for the package that owns this file.
+ *
+ * Falls back to the project-wide value, which is correct for `project()` and for any
+ * project built without going through `workspace()` — an in-memory test double, for
+ * instance. The fallback is the OLD behaviour, so a file the registry does not cover
+ * answers exactly as it did before bug 0058.
+ */
+export function verbatimModuleSyntaxFor(sourceFile) {
+    const byRoot = optionsByProject.get(sourceFile.getProject());
+    if (byRoot !== undefined) {
+        const root = rootOf(sourceFile);
+        if (root !== undefined) {
+            const owned = byRoot.get(root);
+            if (owned !== undefined)
+                return owned.verbatimModuleSyntax;
+        }
+    }
+    return sourceFile.getProject().getCompilerOptions().verbatimModuleSyntax === true;
+}
+//# sourceMappingURL=per-root-compiler-options.js.map

package/dist/core/per-root-compiler-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"per-root-compiler-options.js","sourceRoot":"","sources":["../../src/core/per-root-compiler-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,UAAU,CAAA;AAEpD,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AA6B9C,MAAM,gBAAgB,GAAG,IAAI,OAAO,EAAoD,CAAA;AAExF;;;;;;;;GAQG;AACH,SAAS,eAAe,CAAC,YAAoB;IAC3C,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC;QAChC,gBAAgB,EAAE,YAAY;QAC9B,2BAA2B,EAAE,IAAI;KAClC,CAAC,CAAA;IACF,OAAO,EAAE,oBAAoB,EAAE,MAAM,CAAC,kBAAkB,EAAE,CAAC,oBAAoB,KAAK,IAAI,EAAE,CAAA;AAC5F,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CACzC,cAA8B,EAC9B,aAAgC;IAEhC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAA;IAC7C,KAAK,MAAM,UAAU,IAAI,aAAa,EAAE,CAAC;QACvC,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QACnD,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,IAAI,GAAG,CAAA;QACtD,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC,CAAA;IAC/C,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC;QAAE,gBAAgB,CAAC,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,CAAA;AACnE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CAAC,UAAsB;IAC5D,MAAM,MAAM,GAAG,gBAAgB,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC,CAAA;IAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAA;QAC/B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAC9B,IAAI,KAAK,KAAK,SAAS;gBAAE,OAAO,KAAK,CAAC,oBAAoB,CAAA;QAC5D,CAAC;IACH,CAAC;IACD,OAAO,UAAU,CAAC,UAAU,EAAE,CAAC,kBAAkB,EAAE,CAAC,oBAAoB,KAAK,IAAI,CAAA;AACnF,CAAC"}