@nielspeter/eess-ts 0.2.0 → 0.4.0

package/README.md

@@ -1,7 +1,7 @@
 # @nielspeter/eess-ts
 
 [![npm version](https://img.shields.io/npm/v/@nielspeter/eess-ts)](https://www.npmjs.com/package/@nielspeter/eess-ts)
-[![CI](https://github.com/nielspeter/ts-archunit/actions/workflows/ci.yml/badge.svg)](https://github.com/nielspeter/ts-archunit/actions/workflows/ci.yml)
+[![CI](https://github.com/nielspeter/eess/actions/workflows/ci.yml/badge.svg)](https://github.com/nielspeter/eess/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Node.js >= 24](https://img.shields.io/badge/node-%3E%3D24-brightgreen)](https://nodejs.org/)
 
@@ -9,9 +9,36 @@
 
 Inspired by Java's [ArchUnit](https://www.archunit.org/). Powered by [ts-morph](https://ts-morph.com/).
 
-> **The TypeScript dialect of the [eess](../../README.md) family.** Formerly published as `@nielspeter/ts-archunit` — that name still works as an alias, so existing installs are unaffected. New projects should prefer `@nielspeter/eess-ts`.
+> **The TypeScript dialect of the [eess](https://github.com/nielspeter/eess/blob/main/README.md) family.** Formerly published as `@nielspeter/ts-archunit` — that name still works as an alias, so existing installs are unaffected. New projects should prefer `@nielspeter/eess-ts`. Migrating? See [Migrating from ts-archunit](https://github.com/nielspeter/eess/blob/main/docs/migrating-from-ts-archunit.md).
 
-[Documentation](https://nielspeter.github.io/ts-archunit/) · [Getting Started](https://nielspeter.github.io/ts-archunit/getting-started) · [What Can It Check?](https://nielspeter.github.io/ts-archunit/what-to-check)
+[Documentation](https://github.com/nielspeter/eess) · [Getting Started](https://github.com/nielspeter/eess/blob/main/docs/getting-started.md) · [What Can It Check?](https://github.com/nielspeter/eess/blob/main/docs/what-to-check.md)
+
+## Quickstart — zero to a red gate
+
+A green check you've never seen fail proves nothing. This path takes you to a
+**real, correct violation** — timed at seconds on a warm npm cache, minutes
+cold:
+
+```bash
+npm install -D @nielspeter/eess-ts   # Node >= 24; your project may be ESM or CJS
+npx eess-ts init                     # scaffolds arch.rules.ts — editable guardrail rules
+npx eess-ts check                    # runs them against your source
+```
+
+On most existing codebases the floor fires immediately (a silent `catch {}`,
+an empty stub body, an `eval`). If yours comes up clean — good; now **prove
+the gate is real** the same way eess proves its own gates in CI: introduce a
+violation, watch it go red, revert.
+
+```bash
+echo 'export function probe(s: string): unknown { return eval(s) }' >> src/probe.ts
+npx eess-ts check               # ✗ red — preset/recommended/no-eval, with why + fix
+rm src/probe.ts                 # green again — and now you trust the green
+```
+
+Then wire the rules into your agent's loop — CI annotations, a Claude Code
+hook, and an AGENTS.md block regenerated from the actual rules:
+[agent integration recipes](https://github.com/nielspeter/eess/blob/main/docs/agent-integration.md).
 
 ## The Problem
 
@@ -29,7 +56,7 @@ Code review catches some of this. But at scale — with multiple agents generati
 
 ## The Solution
 
-ts-archunit turns your architecture decisions into executable tests. They run in CI. Violations show up inline on the PR with clear messages explaining **what's wrong, why it matters, and how to fix it** — exactly the context an agent needs to self-correct.
+eess-ts turns your architecture decisions into executable tests. They run in CI. Violations show up inline on the PR with clear messages explaining **what's wrong, why it matters, and how to fix it** — exactly the context an agent needs to self-correct.
 
 ```typescript
 classes(p)
@@ -69,7 +96,7 @@ Every other tool (dependency-cruiser, eslint-plugin-boundaries, ts-arch) only ch
 
 AI agents don't violate architecture by importing wrong files. They violate it by **writing the wrong code in the right place** — inlining logic instead of delegating, using raw APIs instead of abstractions, skipping validation, throwing generic errors.
 
-ts-archunit checks what happens **inside** your functions:
+eess-ts checks what happens **inside** your functions:
 
 ```typescript
 // "Services must delegate to repositories, not hardcode data"
@@ -92,22 +119,22 @@ functions(p)
   .check()
 ```
 
-| Capability                                         | ts-archunit | [dependency-cruiser](https://github.com/sverweij/dependency-cruiser) | [eslint-plugin-boundaries](https://github.com/javierbrea/eslint-plugin-boundaries) | [Biome](https://biomejs.dev) | [ts-arch](https://github.com/ts-arch/ts-arch) |
-| -------------------------------------------------- | ----------- | -------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------- |
-| Import path rules                                  | Yes         | Yes                                                                  | Yes                                                                                | Yes                          | Yes                                           |
-| **Body analysis** (what's called inside functions) | Yes         | No                                                                   | No                                                                                 | No                           | No                                            |
-| **Type checking** (string vs typed union)          | Yes         | No                                                                   | No                                                                                 | No                           | No                                            |
-| JSX element rules                                  | Yes         | No                                                                   | No                                                                                 | No                           | No                                            |
-| Cross-layer rules                                  | Yes         | No                                                                   | No                                                                                 | No                           | Partial                                       |
-| Cycle detection                                    | Yes         | Yes                                                                  | No                                                                                 | No                           | Yes                                           |
-| Code smell detection (duplicate bodies)            | Yes         | No                                                                   | No                                                                                 | No                           | No                                            |
-| Code metrics (cyclomatic, LOC)                     | Yes         | No                                                                   | No                                                                                 | No                           | No                                            |
-| Pattern matching (reusable rule templates)         | Yes         | No                                                                   | No                                                                                 | No                           | No                                            |
-| Baseline (gradual adoption)                        | Yes         | No                                                                   | No                                                                                 | No                           | No                                            |
-| Diff-aware / PR-only checking                      | Yes         | No                                                                   | No                                                                                 | No                           | No                                            |
-| Watch mode                                         | Yes         | No                                                                   | No                                                                                 | Yes                          | No                                            |
-| Inline exclusion comments                          | Yes         | No                                                                   | Via ESLint                                                                         | Yes                          | No                                            |
-| GitHub PR annotations                              | Yes         | No                                                                   | Via ESLint                                                                         | No                           | No                                            |
+| Capability                                         | eess-ts | [dependency-cruiser](https://github.com/sverweij/dependency-cruiser) | [eslint-plugin-boundaries](https://github.com/javierbrea/eslint-plugin-boundaries) | [Biome](https://biomejs.dev) | [ts-arch](https://github.com/ts-arch/ts-arch) |
+| -------------------------------------------------- | ------- | -------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------- |
+| Import path rules                                  | Yes     | Yes                                                                  | Yes                                                                                | Yes                          | Yes                                           |
+| **Body analysis** (what's called inside functions) | Yes     | No                                                                   | No                                                                                 | No                           | No                                            |
+| **Type checking** (string vs typed union)          | Yes     | No                                                                   | No                                                                                 | No                           | No                                            |
+| JSX element rules                                  | Yes     | No                                                                   | No                                                                                 | No                           | No                                            |
+| Cross-layer rules                                  | Yes     | No                                                                   | No                                                                                 | No                           | Partial                                       |
+| Cycle detection                                    | Yes     | Yes                                                                  | No                                                                                 | No                           | Yes                                           |
+| Code smell detection (duplicate bodies)            | Yes     | No                                                                   | No                                                                                 | No                           | No                                            |
+| Code metrics (cyclomatic, LOC)                     | Yes     | No                                                                   | No                                                                                 | No                           | No                                            |
+| Pattern matching (reusable rule templates)         | Yes     | No                                                                   | No                                                                                 | No                           | No                                            |
+| Baseline (gradual adoption)                        | Yes     | No                                                                   | No                                                                                 | No                           | No                                            |
+| Diff-aware / PR-only checking                      | Yes     | No                                                                   | No                                                                                 | No                           | No                                            |
+| Watch mode                                         | Yes     | No                                                                   | No                                                                                 | Yes                          | No                                            |
+| Inline exclusion comments                          | Yes     | No                                                                   | Via ESLint                                                                         | Yes                          | No                                            |
+| GitHub PR annotations                              | Yes     | No                                                                   | Via ESLint                                                                         | No                           | No                                            |
 
 ## Quick Start with Presets
 
@@ -148,7 +175,33 @@ layeredArchitecture(p, {
 - `recommended(p)` — a thin, universal safety floor (no `eval`, no Function constructor, no silent catches, no empty bodies) that fires ~never on healthy code.
 - `agentGuardrails(p, { src })` — the mistakes AI coding agents make most: generic errors, stub comments, empty bodies, copy-paste, and banned inline calls. Each rule carries `imperative` metadata for `explain --format agent`.
 
-Every preset returns `ArchViolation[]` and, by default, throws on any error-severity violation. Pass `{ report: 'return' }` to own emission, `{ report: 'warn' }` to report without failing, or `{ format: 'json' }` for machine-readable output — the caller owns reporting (ADR-008). Per-rule severity is tunable via `overrides`.
+Every preset **runs its rules and throws** on any error-severity violation by
+default — the caller owns reporting (ADR-008). What you pass depends on where you
+are calling it:
+
+| where                             | pass                     | why                                                                                                                       |
+| --------------------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| **a rule file** (`arch.rules.ts`) | `{ report: 'builders' }` | returns the builders **without running them**, so the CLI runs them, reports once, and applies `--baseline` / `--changed` |
+| a test, or your own runner        | `{ report: 'return' }`   | runs the rules and hands you `ArchViolation[]` to assert on                                                               |
+| anywhere, advisory                | `{ report: 'warn' }`     | reports without failing                                                                                                   |
+|                                   | `{ format: 'json' }`     | machine-readable output                                                                                                   |
+
+**`'return'` in a rule file does not work.** A rule file spreads its presets into
+`export default [...]`, so `'return'` splats the preset's _result_ — an
+`ArchViolation[]` — into the rules array. What happens next depends on your
+codebase, and **both outcomes are bad**:
+
+| your codebase  | what you get                                                                                 |
+| -------------- | -------------------------------------------------------------------------------------------- |
+| has violations | the loader rejects it: `default export entry [0] is not a rule builder (got object)`, exit 1 |
+| **is clean**   | the array is **empty**, so the file exports `[]` and every rule silently disappears          |
+
+`tsc --noEmit` catches neither — a spread of the wrong array type is not a type
+error. `check` now refuses a rule file that contributed no rules, so the clean case
+fails too rather than printing a green tick; before that it exited 0. Use
+`'builders'` in a rule file. `eess-ts init` scaffolds it.
+
+Per-rule severity is tunable via `overrides`.
 
 ### Scaffold a starter setup
 
@@ -312,14 +365,14 @@ smells
 
 ### More Features
 
-- **[Call matching](https://nielspeter.github.io/ts-archunit/calls)** — framework-agnostic route/handler inspection (Express, Fastify, Hono)
-- **[Scoped rules](https://nielspeter.github.io/ts-archunit/body-analysis)** — `within(routes).functions()` for callback-level rules
-- **[Pattern templates](https://nielspeter.github.io/ts-archunit/patterns)** — enforce return type shapes (`{ items, total, skip, limit }`)
-- **[GraphQL rules](https://nielspeter.github.io/ts-archunit/graphql)** — schema and resolver conventions
-- **[Cross-layer validation](https://nielspeter.github.io/ts-archunit/cross-layer)** — route/schema/SDK consistency
-- **[Custom predicates and conditions](https://nielspeter.github.io/ts-archunit/custom-rules)** — `definePredicate()`, `defineCondition()`, `and`/`or`/`not` combinators
-- **[Metrics](https://nielspeter.github.io/ts-archunit/metrics)** — cyclomatic complexity, lines of code, method count limits
-- **[CLI](https://nielspeter.github.io/ts-archunit/cli)** — `check`, `baseline`, `explain`, `--watch` mode
+- **[Call matching](https://github.com/nielspeter/eess/blob/main/docs/calls.md)** — framework-agnostic route/handler inspection (Express, Fastify, Hono)
+- **[Scoped rules](https://github.com/nielspeter/eess/blob/main/docs/body-analysis.md)** — `within(routes).functions()` for callback-level rules
+- **[Pattern templates](https://github.com/nielspeter/eess/blob/main/docs/patterns.md)** — enforce return type shapes (`{ items, total, skip, limit }`)
+- **[GraphQL rules](https://github.com/nielspeter/eess/blob/main/docs/graphql.md)** — schema and resolver conventions
+- **[Cross-layer validation](https://github.com/nielspeter/eess/blob/main/docs/cross-layer.md)** — route/schema/SDK consistency
+- **[Custom predicates and conditions](https://github.com/nielspeter/eess/blob/main/docs/custom-rules.md)** — `definePredicate()`, `defineCondition()`, `and`/`or`/`not` combinators
+- **[Metrics](https://github.com/nielspeter/eess/blob/main/docs/metrics.md)** — cyclomatic complexity, lines of code, method count limits
+- **[CLI](https://github.com/nielspeter/eess/blob/main/docs/cli.md)** — `check`, `baseline`, `explain`, `--watch` mode
 
 ## Entry Points
 
@@ -336,7 +389,7 @@ smells
 
 ## Compared to Other Tools
 
-| Capability                                        | ts-archunit     | [dependency-cruiser](https://github.com/sverweij/dependency-cruiser) | [ArchUnitTS](https://github.com/LukasNiessen/ArchUnitTS) | [Biome](https://biomejs.dev) | [ts-arch](https://github.com/ts-arch/ts-arch) |
+| Capability                                        | eess-ts         | [dependency-cruiser](https://github.com/sverweij/dependency-cruiser) | [ArchUnitTS](https://github.com/LukasNiessen/ArchUnitTS) | [Biome](https://biomejs.dev) | [ts-arch](https://github.com/ts-arch/ts-arch) |
 | ------------------------------------------------- | --------------- | -------------------------------------------------------------------- | -------------------------------------------------------- | ---------------------------- | --------------------------------------------- |
 | Import path rules                                 | Yes             | Yes                                                                  | Yes                                                      | Yes (`noRestrictedImports`)  | Yes                                           |
 | **Body analysis** (calls, access, constructors)   | Yes             | No                                                                   | No                                                       | No                           | No                                            |
@@ -363,17 +416,17 @@ smells
 | License checking                                  | No              | Yes                                                                  | No                                                       | No                           | No                                            |
 | Nx monorepo support                               | No              | No                                                                   | Yes                                                      | No                           | No                                            |
 
-**Use ts-archunit** when you need to enforce what happens _inside_ functions — call patterns, error types, missing delegation, stub comments — and when AI agents are generating code that needs architectural guardrails. This is the only tool that catches "service calls parseInt instead of extractCount()", flags duplicate function bodies as smells, and can restrict checking to only the files changed in a PR.
+**Use eess-ts** when you need to enforce what happens _inside_ functions — call patterns, error types, missing delegation, stub comments — and when AI agents are generating code that needs architectural guardrails. This is the only tool that catches "service calls parseInt instead of extractCount()", flags duplicate function bodies as smells, and can restrict checking to only the files changed in a PR.
 
 **Use dependency-cruiser** when you only need import direction rules and want fast graph visualization, license compliance checking, or stability metrics. It's faster (no ts-morph project load) and has mature HTML/dot reporting.
 
 **Use ArchUnitTS** when you need OO metrics (LCOM cohesion, coupling factor, distance from main sequence), PlantUML diagram validation, or Nx monorepo project-graph awareness.
 
-**Use Biome** when you want a fast Rust-based lint + format toolchain and only need lint-level import restrictions (`noRestrictedImports`) — not architecture rules over class hierarchies, function bodies, or slice cycles. Pair it with ts-archunit if you want both.
+**Use Biome** when you want a fast Rust-based lint + format toolchain and only need lint-level import restrictions (`noRestrictedImports`) — not architecture rules over class hierarchies, function bodies, or slice cycles. Pair it with eess-ts if you want both.
 
 **Use ts-arch** when you want the classic ArchUnit-style fluent API scoped to file/folder dependency rules and layered slices, and don't need body analysis, type-checker rules, or CI integrations like baselines, diff-aware runs, or GitHub annotations.
 
-**Use ts-archunit + dependency-cruiser together** if you want both body-level enforcement and dependency graph visualization.
+**Use eess-ts + dependency-cruiser together** if you want both body-level enforcement and dependency graph visualization.
 
 ## Install
 

package/dist/builders/call-rule-builder.d.ts

@@ -1,5 +1,5 @@
 import type { ArchProject } from '../core/project.js';
-import { RuleBuilder } from '@nielspeter/eess';
+import { RuleBuilder } from '../core/rule-builder.js';
 import type { ConditionContext } from '@nielspeter/eess';
 import type { ExpressionMatcher } from '../helpers/matchers.js';
 import type { ArchCall } from '../models/arch-call.js';
@@ -36,53 +36,98 @@ import type { ArchCall } from '../models/arch-call.js';
  *   .check()
  * ```
  */
-export declare class CallRuleBuilder extends RuleBuilder<ArchCall, ArchProject> {
+export declare class CallRuleBuilder extends RuleBuilder<ArchCall> {
     /**
      * Argument index to fold into the violation element/message. Set by
      * `.identifiedByArg(index)`. Threaded into `ConditionContext.identifyByArgument`
      * so the eight `archCall.getName()` sites in `src/conditions/call.ts`
      * can build identity-keyed violation strings.
      *
-     * Survives `fork()` via `Object.assign(fork, this)` in the base class
-     * (primitive field; no explicit copy needed). See plan 0057.
+     * Survives a copy via `shallowClone` in `TerminalBuilder.copy` (a primitive
+     * field, so no `copy()` override is needed). See plan 0057.
      */
     protected _identifyByArgument?: number;
     protected getElements(): ArchCall[];
     protected buildConditionContext(): ConditionContext;
     /**
-     * Filter to calls whose callee name matches the pattern.
-     * A string is compiled to a RegExp. For `app.get(...)` the name is `app.get`.
+     * Narrows the selection to call expressions that have a name matching `pattern`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     haveNameMatching(pattern: RegExp | string): this;
-    /** Filter to calls whose callee name starts with the given prefix. */
+    /**
+     * Narrows the selection to call expressions that have a name starting with `prefix`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
+     */
     haveNameStartingWith(prefix: string): this;
-    /** Filter to calls whose callee name ends with the given suffix. */
+    /**
+     * Narrows the selection to call expressions that have a name ending with `suffix`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
+     */
     haveNameEndingWith(suffix: string): this;
-    /** Filter to calls in a file whose absolute path matches the glob. */
+    /**
+     * Narrows the selection to call expressions that reside in a file matching `glob`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
+     */
     resideInFile(glob: string): this;
-    /** Filter to calls in a folder whose path matches the glob. */
+    /**
+     * Narrows the selection to call expressions that reside in a folder matching `glob`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
+     */
     resideInFolder(glob: string): this;
     /**
-     * Filter to method calls on the object with the exact given name.
-     * For `app.get(...)` use `onObject('app')`; for `router.route.get(...)`
-     * use `onObject('router.route')`. Optional chaining is normalized.
+     * Narrows the selection to call expressions that are called on the object `name`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     onObject(name: string): this;
     /**
-     * Filter to calls whose method name matches. Accepts an exact string
-     * or a regex; also matches bare function calls (`handleError(...)`).
+     * Narrows the selection to call expressions that call a method matching `nameOrRegex`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     withMethod(nameOrRegex: string | RegExp): this;
     /**
-     * Filter to calls whose argument at `index` matches the pattern, tested
-     * against the argument's source text (so it matches identifiers and
-     * expressions, not just string literals).
+     * Narrows the selection to call expressions that have argument `index` matching `pattern`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     withArgMatching(index: number, pattern: string | RegExp): this;
     /**
-     * Filter to calls whose argument at `index` is a string literal whose
-     * value matches the glob. Non-literal arguments (variables, expressions)
-     * never match.
+     * Narrows the selection to call expressions that have string argument `index` matching `glob`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     withStringArg(index: number, glob: string): this;
     /**
@@ -166,11 +211,6 @@ export declare class CallRuleBuilder extends RuleBuilder<ArchCall, ArchProject>
      * Use `notHaveCallbackContaining` when you only want to search callback bodies.
      */
     notHaveArgumentContaining(matcher: ExpressionMatcher): this;
-    /**
-     * Get the underlying ArchProject.
-     * Used by within() to create scoped builders.
-     */
-    getProject(): ArchProject;
     /**
      * Get the ArchCall elements that match the current predicate chain.
      * Used by within() to extract callbacks from matched calls.

package/dist/builders/call-rule-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"call-rule-builder.d.ts","sourceRoot":"","sources":["../../src/builders/call-rule-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAyBtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,eAAgB,SAAQ,WAAW,CAAC,QAAQ,EAAE,WAAW,CAAC;IACrE;;;;;;;;OAQG;IACH,SAAS,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAEtC,SAAS,CAAC,WAAW,IAAI,QAAQ,EAAE;cAIhB,qBAAqB,IAAI,gBAAgB;IAS5D;;;OAGG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIhD,sEAAsE;IACtE,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI1C,oEAAoE;IACpE,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIxC,sEAAsE;IACtE,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIhC,+DAA+D;IAC/D,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IASlC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI5B;;;OAGG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI9C;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI9D;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAMhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAOpC;;OAEG;IACH,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAIxD;;OAEG;IACH,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAI3D;;OAEG;IACH,QAAQ,IAAI,IAAI;IAIhB;;OAEG;IACH,wBAAwB,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlD;;OAEG;IACH,2BAA2B,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAIrD;;;;;OAKG;IACH,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAIxD;;;;;OAKG;IACH,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAM3D;;;OAGG;IACH,UAAU,IAAI,WAAW;IAIzB;;;OAGG;IACH,eAAe,IAAI,QAAQ,EAAE;CAG9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,WAAW,GAAG,eAAe,CAErD"}
+{"version":3,"file":"call-rule-builder.d.ts","sourceRoot":"","sources":["../../src/builders/call-rule-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AA6BtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,eAAgB,SAAQ,WAAW,CAAC,QAAQ,CAAC;IACxD;;;;;;;;OAQG;IACH,SAAS,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAEtC,SAAS,CAAC,WAAW,IAAI,QAAQ,EAAE;cAMhB,qBAAqB,IAAI,gBAAgB;IAS5D;;;;;;;OAOG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIhD;;;;;;;OAOG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI1C;;;;;;;OAOG;IACH,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIxC;;;;;;;OAOG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIhC;;;;;;;OAOG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IASlC;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI5B;;;;;;;OAOG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI9C;;;;;;;OAOG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI9D;;;;;;;OAOG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAMhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQpC;;OAEG;IACH,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAIxD;;OAEG;IACH,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAI3D;;OAEG;IACH,QAAQ,IAAI,IAAI;IAIhB;;OAEG;IACH,wBAAwB,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlD;;OAEG;IACH,2BAA2B,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAIrD;;;;;OAKG;IACH,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAIxD;;;;;OAKG;IACH,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAM3D;;;OAGG;IACH,eAAe,IAAI,QAAQ,EAAE;CAG9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,WAAW,GAAG,eAAe,CAErD"}

package/dist/builders/call-rule-builder.js

@@ -1,5 +1,8 @@
-import { RuleBuilder } from '@nielspeter/eess';
+import { RuleBuilder } from '../core/rule-builder.js';
 import { collectCalls } from '../models/arch-call.js';
+import { createElementCache, SOLE_POPULATION } from '../core/element-cache.js';
+/** One collection per project, shared by every rule built from it (plan 0075). */
+const cache = createElementCache();
 import { haveNameMatching as identityHaveNameMatching, haveNameStartingWith as identityHaveNameStartingWith, haveNameEndingWith as identityHaveNameEndingWith, resideInFile as identityResideInFile, resideInFolder as identityResideInFolder, } from '../predicates/identity.js';
 import { onObject as callOnObject, withMethod as callWithMethod, withArgMatching as callWithArgMatching, withStringArg as callWithStringArg, } from '../predicates/call.js';
 import { haveCallbackContaining as conditionHaveCallbackContaining, notHaveCallbackContaining as conditionNotHaveCallbackContaining, notExist as callNotExist, haveArgumentWithProperty as conditionHaveArgumentWithProperty, notHaveArgumentWithProperty as conditionNotHaveArgumentWithProperty, haveArgumentContaining as conditionHaveArgumentContaining, notHaveArgumentContaining as conditionNotHaveArgumentContaining, } from '../conditions/call.js';
@@ -43,12 +46,12 @@ export class CallRuleBuilder extends RuleBuilder {
      * so the eight `archCall.getName()` sites in `src/conditions/call.ts`
      * can build identity-keyed violation strings.
      *
-     * Survives `fork()` via `Object.assign(fork, this)` in the base class
-     * (primitive field; no explicit copy needed). See plan 0057.
+     * Survives a copy via `shallowClone` in `TerminalBuilder.copy` (a primitive
+     * field, so no `copy()` override is needed). See plan 0057.
      */
     _identifyByArgument;
     getElements() {
-        return this.project.getSourceFiles().flatMap(collectCalls);
+        return cache.get(this.project, SOLE_POPULATION, () => this.project.getSourceFiles().flatMap(collectCalls));
     }
     buildConditionContext() {
         return {
@@ -58,58 +61,103 @@ export class CallRuleBuilder extends RuleBuilder {
     }
     // --- Identity predicates (subset: no areExported/areNotExported) ---
     /**
-     * Filter to calls whose callee name matches the pattern.
-     * A string is compiled to a RegExp. For `app.get(...)` the name is `app.get`.
+     * Narrows the selection to call expressions that have a name matching `pattern`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     haveNameMatching(pattern) {
         return this.addPredicate(identityHaveNameMatching(pattern));
     }
-    /** Filter to calls whose callee name starts with the given prefix. */
+    /**
+     * Narrows the selection to call expressions that have a name starting with `prefix`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
+     */
     haveNameStartingWith(prefix) {
         return this.addPredicate(identityHaveNameStartingWith(prefix));
     }
-    /** Filter to calls whose callee name ends with the given suffix. */
+    /**
+     * Narrows the selection to call expressions that have a name ending with `suffix`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
+     */
     haveNameEndingWith(suffix) {
         return this.addPredicate(identityHaveNameEndingWith(suffix));
     }
-    /** Filter to calls in a file whose absolute path matches the glob. */
+    /**
+     * Narrows the selection to call expressions that reside in a file matching `glob`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
+     */
     resideInFile(glob) {
         return this.addPredicate(identityResideInFile(glob));
     }
-    /** Filter to calls in a folder whose path matches the glob. */
+    /**
+     * Narrows the selection to call expressions that reside in a folder matching `glob`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
+     */
     resideInFolder(glob) {
         return this.addPredicate(identityResideInFolder(glob));
     }
     // Note: areExported() and areNotExported() are intentionally omitted.
-    // Call expressions cannot be exported. See spec section 5.1.
+    // Call expressions cannot are exported. See spec section 5.1.
     // --- Call-specific predicates ---
     /**
-     * Filter to method calls on the object with the exact given name.
-     * For `app.get(...)` use `onObject('app')`; for `router.route.get(...)`
-     * use `onObject('router.route')`. Optional chaining is normalized.
+     * Narrows the selection to call expressions that are called on the object `name`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     onObject(name) {
         return this.addPredicate(callOnObject(name));
     }
     /**
-     * Filter to calls whose method name matches. Accepts an exact string
-     * or a regex; also matches bare function calls (`handleError(...)`).
+     * Narrows the selection to call expressions that call a method matching `nameOrRegex`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     withMethod(nameOrRegex) {
         return this.addPredicate(callWithMethod(nameOrRegex));
     }
     /**
-     * Filter to calls whose argument at `index` matches the pattern, tested
-     * against the argument's source text (so it matches identifiers and
-     * expressions, not just string literals).
+     * Narrows the selection to call expressions that have argument `index` matching `pattern`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     withArgMatching(index, pattern) {
         return this.addPredicate(callWithArgMatching(index, pattern));
     }
     /**
-     * Filter to calls whose argument at `index` is a string literal whose
-     * value matches the glob. Non-literal arguments (variables, expressions)
-     * never match.
+     * Narrows the selection to call expressions that have string argument `index` matching `glob`.
+     *
+     * **Predicate only**, unlike the dual-use methods on this builder: it never
+     * becomes an assertion. Written after `.should()` it still filters, and the
+     * assertion gate reports it as a misplaced predicate rather than letting the
+     * rule pass having asserted nothing.
      */
     withStringArg(index, glob) {
         return this.addPredicate(callWithStringArg(index, glob));
@@ -162,8 +210,9 @@ export class CallRuleBuilder extends RuleBuilder {
      * @param index — zero-based argument index to fold into the identity.
      */
     identifiedByArg(index) {
-        this._identifyByArgument = index;
-        return this;
+        const next = this.copy();
+        next._identifyByArgument = index;
+        return next;
     }
     // --- Condition methods ---
     /**
@@ -215,13 +264,6 @@ export class CallRuleBuilder extends RuleBuilder {
         return this.addCondition(conditionNotHaveArgumentContaining(matcher));
     }
     // --- Public accessors (used by plan 0015 within()) ---
-    /**
-     * Get the underlying ArchProject.
-     * Used by within() to create scoped builders.
-     */
-    getProject() {
-        return this.project;
-    }
     /**
      * Get the ArchCall elements that match the current predicate chain.
      * Used by within() to extract callbacks from matched calls.

package/dist/builders/call-rule-builder.js.map

@@ -1 +1 @@
-{"version":3,"file":"call-rule-builder.js","sourceRoot":"","sources":["../../src/builders/call-rule-builder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"call-rule-builder.js","sourceRoot":"","sources":["../../src/builders/call-rule-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE9E,kFAAkF;AAClF,MAAM,KAAK,GAAG,kBAAkB,EAAY,CAAA;AAC5C,OAAO,EACL,gBAAgB,IAAI,wBAAwB,EAC5C,oBAAoB,IAAI,4BAA4B,EACpD,kBAAkB,IAAI,0BAA0B,EAChD,YAAY,IAAI,oBAAoB,EACpC,cAAc,IAAI,sBAAsB,GACzC,MAAM,2BAA2B,CAAA;AAClC,OAAO,EACL,QAAQ,IAAI,YAAY,EACxB,UAAU,IAAI,cAAc,EAC5B,eAAe,IAAI,mBAAmB,EACtC,aAAa,IAAI,iBAAiB,GACnC,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,sBAAsB,IAAI,+BAA+B,EACzD,yBAAyB,IAAI,kCAAkC,EAC/D,QAAQ,IAAI,YAAY,EACxB,wBAAwB,IAAI,iCAAiC,EAC7D,2BAA2B,IAAI,oCAAoC,EACnE,sBAAsB,IAAI,+BAA+B,EACzD,yBAAyB,IAAI,kCAAkC,GAChE,MAAM,uBAAuB,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,OAAO,eAAgB,SAAQ,WAAqB;IACxD;;;;;;;;OAQG;IACO,mBAAmB,CAAS;IAE5B,WAAW;QACnB,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,EAAE,CACnD,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC,CACpD,CAAA;IACH,CAAC;IAEkB,qBAAqB;QACtC,OAAO;YACL,GAAG,KAAK,CAAC,qBAAqB,EAAE;YAChC,kBAAkB,EAAE,IAAI,CAAC,mBAAmB;SAC7C,CAAA;IACH,CAAC;IAED,sEAAsE;IAEtE;;;;;;;OAOG;IACH,gBAAgB,CAAC,OAAwB;QACvC,OAAO,IAAI,CAAC,YAAY,CAAC,wBAAwB,CAAW,OAAO,CAAC,CAAC,CAAA;IACvE,CAAC;IAED;;;;;;;OAOG;IACH,oBAAoB,CAAC,MAAc;QACjC,OAAO,IAAI,CAAC,YAAY,CAAC,4BAA4B,CAAW,MAAM,CAAC,CAAC,CAAA;IAC1E,CAAC;IAED;;;;;;;OAOG;IACH,kBAAkB,CAAC,MAAc;QAC/B,OAAO,IAAI,CAAC,YAAY,CAAC,0BAA0B,CAAW,MAAM,CAAC,CAAC,CAAA;IACxE,CAAC;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,IAAY;QACvB,OAAO,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAW,IAAI,CAAC,CAAC,CAAA;IAChE,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,IAAY;QACzB,OAAO,IAAI,CAAC,YAAY,CAAC,sBAAsB,CAAW,IAAI,CAAC,CAAC,CAAA;IAClE,CAAC;IAED,sEAAsE;IACtE,8DAA8D;IAE9D,mCAAmC;IAEnC;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAY;QACnB,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAA;IAC9C,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,WAA4B;QACrC,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,CAAA;IACvD,CAAC;IAED;;;;;;;OAOG;IACH,eAAe,CAAC,KAAa,EAAE,OAAwB;QACrD,OAAO,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAA;IAC/D,CAAC;IAED;;;;;;;OAOG;IACH,aAAa,CAAC,KAAa,EAAE,IAAY;QACvC,OAAO,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAA;IAC1D,CAAC;IAED,8BAA8B;IAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,eAAe,CAAC,KAAa;QAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAA;QACxB,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAA;QAChC,OAAO,IAAI,CAAA;IACb,CAAC;IAED,4BAA4B;IAE5B;;OAEG;IACH,sBAAsB,CAAC,OAA0B;QAC/C,OAAO,IAAI,CAAC,YAAY,CAAC,+BAA+B,CAAC,OAAO,CAAC,CAAC,CAAA;IACpE,CAAC;IAED;;OAEG;IACH,yBAAyB,CAAC,OAA0B;QAClD,OAAO,IAAI,CAAC,YAAY,CAAC,kCAAkC,CAAC,OAAO,CAAC,CAAC,CAAA;IACvE,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC,CAAA;IAC1C,CAAC;IAED;;OAEG;IACH,wBAAwB,CAAC,GAAG,KAAe;QACzC,OAAO,IAAI,CAAC,YAAY,CAAC,iCAAiC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAA;IACvE,CAAC;IAED;;OAEG;IACH,2BAA2B,CAAC,GAAG,KAAe;QAC5C,OAAO,IAAI,CAAC,YAAY,CAAC,oCAAoC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAA;IAC1E,CAAC;IAED;;;;;OAKG;IACH,sBAAsB,CAAC,OAA0B;QAC/C,OAAO,IAAI,CAAC,YAAY,CAAC,+BAA+B,CAAC,OAAO,CAAC,CAAC,CAAA;IACpE,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAC,OAA0B;QAClD,OAAO,IAAI,CAAC,YAAY,CAAC,kCAAkC,CAAC,OAAO,CAAC,CAAC,CAAA;IACvE,CAAC;IAED,wDAAwD;IAExD;;;OAGG;IACH,eAAe;QACb,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;IACjG,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,KAAK,CAAC,CAAc;IAClC,OAAO,IAAI,eAAe,CAAC,CAAC,CAAC,CAAA;AAC/B,CAAC"}