@webpieces/code-rules 0.3.351 → 0.3.352

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/code-rules",
-  "version": "0.3.351",
+  "version": "0.3.352",
   "description": "Standalone code validation rules extracted from architecture-validators, no Nx dependency required",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -20,7 +20,12 @@
     "directory": "packages/tooling/code-rules"
   },
   "dependencies": {
-    "@webpieces/rules-config": "0.3.351"
+    "@webpieces/rules-config": "0.3.352",
+    "@webpieces/core-context": "0.3.352",
+    "@webpieces/core-util": "0.3.352",
+    "@inversifyjs/binding-decorators": "1.1.5",
+    "inversify": "7.10.4",
+    "reflect-metadata": "0.2.2"
   },
   "publishConfig": {
     "access": "public"

package/src/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import 'reflect-metadata';

package/src/cli.js

@@ -1,16 +1,38 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
+require("reflect-metadata");
+const inversify_1 = require("inversify");
+const binding_decorators_1 = require("@inversifyjs/binding-decorators");
 const rules_config_1 = require("@webpieces/rules-config");
-const validate_code_1 = tslib_1.__importDefault(require("./validate-code"));
+const code_rules_app_1 = require("./code-rules-app");
+const code_rules_context_1 = require("./code-rules-context");
+const code_rules_config_table_1 = require("./code-rules-config-table");
 async function main() {
     // webpieces-disable no-unmanaged-exceptions -- global entry point for code-rules CLI
     try {
-        // Anchor at the repo root so `.webpieces/instruct-ai` docs are written there, not in whatever
-        // subdir this CLI happened to be invoked from.
+        // Anchor at the repo root so `.webpieces/instruct-ai` docs land there, not in whatever subdir
+        // this CLI ran from; load config from there.
         const workspaceRoot = new rules_config_1.RepoRootFinder().resolveRepoRoot(process.cwd());
-        const result = await (0, validate_code_1.default)(workspaceRoot);
+        const loaded = (0, rules_config_1.loadAndValidate)(workspaceRoot);
+        if (loaded.configPath === null) {
+            console.error('\n❌ No webpieces.config.json found at workspace root (or any ancestor).\n');
+            process.exit(1);
+        }
+        console.log(`\n📄 Loaded config: ${loaded.configPath}`);
+        // Composition root: bind the runtime values (workspace root, each rule's config), then let
+        // inversify build the ENTIRE validator DAG when we resolve the app.
+        const container = new inversify_1.Container();
+        container.bind(code_rules_context_1.WorkspaceRoot).toConstantValue(new code_rules_context_1.WorkspaceRoot(workspaceRoot));
+        container.bind(code_rules_context_1.MatchRulesHolder).toConstantValue(new code_rules_context_1.MatchRulesHolder(loaded.matchRules));
+        for (const binding of code_rules_config_table_1.CONFIG_BINDINGS) {
+            const ConfigClass = binding[0];
+            const configured = loaded.rulesConfig[binding[1]];
+            container.bind(ConfigClass).toConstantValue(configured ?? new ConfigClass());
+        }
+        await container.load((0, binding_decorators_1.buildProviderModule)());
+        const app = container.get(code_rules_app_1.CodeRulesApp);
+        const result = await app.run();
         process.exit(result.success ? 0 : 1);
     }
     catch (err) {

package/src/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../../../../packages/tooling/code-rules/src/cli.ts"],"names":[],"mappings":";;;;AACA,0DAAgG;AAChG,4EAA8C;AAE9C,KAAK,UAAU,IAAI;IACf,qFAAqF;IACrF,IAAI,CAAC;QACD,8FAA8F;QAC9F,+CAA+C;QAC/C,MAAM,aAAa,GAAG,IAAI,6BAAc,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAC1E,MAAM,MAAM,GAAG,MAAM,IAAA,uBAAe,EAAC,aAAa,CAAC,CAAC;QACpD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACpB,MAAM,KAAK,GAAG,IAAA,sBAAO,EAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,KAAK,YAAY,4BAAa,EAAE,CAAC;YACjC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACtC,CAAC;aAAM,IAAI,GAAG,YAAY,4BAAa,EAAE,CAAC;YACtC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;aAAM,CAAC;YACJ,OAAO,CAAC,KAAK,CAAC,kCAAkC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACrE,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;AACL,CAAC;AAED,IAAI,EAAE,CAAC","sourcesContent":["#!/usr/bin/env node\nimport { InformAiError, RuleFailError, toError, RepoRootFinder } from '@webpieces/rules-config';\nimport runValidateCode from './validate-code';\n\nasync function main(): Promise<void> {\n    // webpieces-disable no-unmanaged-exceptions -- global entry point for code-rules CLI\n    try {\n        // Anchor at the repo root so `.webpieces/instruct-ai` docs are written there, not in whatever\n        // subdir this CLI happened to be invoked from.\n        const workspaceRoot = new RepoRootFinder().resolveRepoRoot(process.cwd());\n        const result = await runValidateCode(workspaceRoot);\n        process.exit(result.success ? 0 : 1);\n    } catch (err: unknown) {\n        const error = toError(err);\n        if (error instanceof RuleFailError) {\n            console.error(error.humanMessage);\n        } else if (err instanceof InformAiError) {\n            console.error(error.message);\n        } else {\n            console.error(`[code-rules] unexpected error: ${error.message}`);\n        }\n        process.exit(1);\n    }\n}\n\nmain();\n"]}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../../../../packages/tooling/code-rules/src/cli.ts"],"names":[],"mappings":";;;AACA,4BAA0B;AAC1B,yCAAsC;AACtC,wEAAsE;AACtE,0DAAiI;AAEjI,qDAAgD;AAChD,6DAAuE;AACvE,uEAA4D;AAE5D,KAAK,UAAU,IAAI;IACf,qFAAqF;IACrF,IAAI,CAAC;QACD,8FAA8F;QAC9F,6CAA6C;QAC7C,MAAM,aAAa,GAAG,IAAI,6BAAc,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAC1E,MAAM,MAAM,GAAG,IAAA,8BAAe,EAAC,aAAa,CAAC,CAAC;QAC9C,IAAI,MAAM,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAC7B,OAAO,CAAC,KAAK,CAAC,2EAA2E,CAAC,CAAC;YAC3F,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,uBAAuB,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;QAExD,2FAA2F;QAC3F,oEAAoE;QACpE,MAAM,SAAS,GAAG,IAAI,qBAAS,EAAE,CAAC;QAClC,SAAS,CAAC,IAAI,CAAC,kCAAa,CAAC,CAAC,eAAe,CAAC,IAAI,kCAAa,CAAC,aAAa,CAAC,CAAC,CAAC;QAChF,SAAS,CAAC,IAAI,CAAC,qCAAgB,CAAC,CAAC,eAAe,CAAC,IAAI,qCAAgB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;QAC1F,KAAK,MAAM,OAAO,IAAI,yCAAe,EAAE,CAAC;YACpC,MAAM,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC/B,MAAM,UAAU,GAAG,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAA+B,CAAC;YAChF,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,eAAe,CAAC,UAAU,IAAI,IAAI,WAAW,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,MAAM,SAAS,CAAC,IAAI,CAAC,IAAA,wCAAmB,GAAE,CAAC,CAAC;QAE5C,MAAM,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC,6BAAY,CAAC,CAAC;QACxC,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,GAAG,EAAE,CAAC;QAC/B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACpB,MAAM,KAAK,GAAG,IAAA,sBAAO,EAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,KAAK,YAAY,4BAAa,EAAE,CAAC;YACjC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACtC,CAAC;aAAM,IAAI,GAAG,YAAY,4BAAa,EAAE,CAAC;YACtC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;aAAM,CAAC;YACJ,OAAO,CAAC,KAAK,CAAC,kCAAkC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACrE,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;AACL,CAAC;AAED,IAAI,EAAE,CAAC","sourcesContent":["#!/usr/bin/env node\nimport 'reflect-metadata';\nimport { Container } from 'inversify';\nimport { buildProviderModule } from '@inversifyjs/binding-decorators';\nimport { InformAiError, RuleFailError, toError, loadAndValidate, RepoRootFinder, BaseRuleConfig } from '@webpieces/rules-config';\n\nimport { CodeRulesApp } from './code-rules-app';\nimport { WorkspaceRoot, MatchRulesHolder } from './code-rules-context';\nimport { CONFIG_BINDINGS } from './code-rules-config-table';\n\nasync function main(): Promise<void> {\n    // webpieces-disable no-unmanaged-exceptions -- global entry point for code-rules CLI\n    try {\n        // Anchor at the repo root so `.webpieces/instruct-ai` docs land there, not in whatever subdir\n        // this CLI ran from; load config from there.\n        const workspaceRoot = new RepoRootFinder().resolveRepoRoot(process.cwd());\n        const loaded = loadAndValidate(workspaceRoot);\n        if (loaded.configPath === null) {\n            console.error('\\n❌ No webpieces.config.json found at workspace root (or any ancestor).\\n');\n            process.exit(1);\n        }\n        console.log(`\\n📄 Loaded config: ${loaded.configPath}`);\n\n        // Composition root: bind the runtime values (workspace root, each rule's config), then let\n        // inversify build the ENTIRE validator DAG when we resolve the app.\n        const container = new Container();\n        container.bind(WorkspaceRoot).toConstantValue(new WorkspaceRoot(workspaceRoot));\n        container.bind(MatchRulesHolder).toConstantValue(new MatchRulesHolder(loaded.matchRules));\n        for (const binding of CONFIG_BINDINGS) {\n            const ConfigClass = binding[0];\n            const configured = loaded.rulesConfig[binding[1]] as BaseRuleConfig | undefined;\n            container.bind(ConfigClass).toConstantValue(configured ?? new ConfigClass());\n        }\n        await container.load(buildProviderModule());\n\n        const app = container.get(CodeRulesApp);\n        const result = await app.run();\n        process.exit(result.success ? 0 : 1);\n    } catch (err: unknown) {\n        const error = toError(err);\n        if (error instanceof RuleFailError) {\n            console.error(error.humanMessage);\n        } else if (err instanceof InformAiError) {\n            console.error(error.message);\n        } else {\n            console.error(`[code-rules] unexpected error: ${error.message}`);\n        }\n        process.exit(1);\n    }\n}\n\nmain();\n"]}

package/src/code-rules-app.d.ts

@@ -0,0 +1,13 @@
+import { CodeRulesEngine } from './code-rules-engine';
+import { ExecutorResult } from './code-validator';
+/**
+ * The code-rules application root. `container.get(CodeRulesApp)` resolves the entire validator DAG
+ * (engine → 18 injected validators → their bound configs + shared helpers). `@DocumentDesign` marks
+ * it the top-of-DAG the DI-design analyzer roots on, so `role:app` code-rules draws its design.
+ */
+export declare class CodeRulesApp {
+    private readonly engine;
+    constructor(engine: CodeRulesEngine);
+    /** Run every configured code validator against the workspace root bound at bootstrap. */
+    run(): Promise<ExecutorResult>;
+}

package/src/code-rules-app.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeRulesApp = void 0;
+const tslib_1 = require("tslib");
+const core_util_1 = require("@webpieces/core-util");
+const core_context_1 = require("@webpieces/core-context");
+const inversify_1 = require("inversify");
+const code_rules_engine_1 = require("./code-rules-engine");
+/**
+ * The code-rules application root. `container.get(CodeRulesApp)` resolves the entire validator DAG
+ * (engine → 18 injected validators → their bound configs + shared helpers). `@DocumentDesign` marks
+ * it the top-of-DAG the DI-design analyzer roots on, so `role:app` code-rules draws its design.
+ */
+let CodeRulesApp = class CodeRulesApp {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    /** Run every configured code validator against the workspace root bound at bootstrap. */
+    run() {
+        return this.engine.run();
+    }
+};
+exports.CodeRulesApp = CodeRulesApp;
+exports.CodeRulesApp = CodeRulesApp = tslib_1.__decorate([
+    (0, core_util_1.DocumentDesign)(),
+    (0, core_context_1.provideSingleton)(),
+    (0, inversify_1.injectable)(),
+    tslib_1.__metadata("design:paramtypes", [code_rules_engine_1.CodeRulesEngine])
+], CodeRulesApp);
+//# sourceMappingURL=code-rules-app.js.map

package/src/code-rules-app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-rules-app.js","sourceRoot":"","sources":["../../../../../packages/tooling/code-rules/src/code-rules-app.ts"],"names":[],"mappings":";;;;AAAA,oDAAsD;AACtD,0DAA2D;AAC3D,yCAAuC;AAEvC,2DAAsD;AAGtD;;;;GAIG;AAII,IAAM,YAAY,GAAlB,MAAM,YAAY;IACQ;IAA7B,YAA6B,MAAuB;QAAvB,WAAM,GAAN,MAAM,CAAiB;IAAG,CAAC;IAExD,yFAAyF;IACzF,GAAG;QACC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;IAC7B,CAAC;CACJ,CAAA;AAPY,oCAAY;uBAAZ,YAAY;IAHxB,IAAA,0BAAc,GAAE;IAChB,IAAA,+BAAgB,GAAE;IAClB,IAAA,sBAAU,GAAE;6CAE4B,mCAAe;GAD3C,YAAY,CAOxB","sourcesContent":["import { DocumentDesign } from '@webpieces/core-util';\nimport { provideSingleton } from '@webpieces/core-context';\nimport { injectable } from 'inversify';\n\nimport { CodeRulesEngine } from './code-rules-engine';\nimport { ExecutorResult } from './code-validator';\n\n/**\n * The code-rules application root. `container.get(CodeRulesApp)` resolves the entire validator DAG\n * (engine → 18 injected validators → their bound configs + shared helpers). `@DocumentDesign` marks\n * it the top-of-DAG the DI-design analyzer roots on, so `role:app` code-rules draws its design.\n */\n@DocumentDesign()\n@provideSingleton()\n@injectable()\nexport class CodeRulesApp {\n    constructor(private readonly engine: CodeRulesEngine) {}\n\n    /** Run every configured code validator against the workspace root bound at bootstrap. */\n    run(): Promise<ExecutorResult> {\n        return this.engine.run();\n    }\n}\n"]}

package/src/code-rules-config-table.d.ts

@@ -0,0 +1,10 @@
+import { BaseRuleConfig, WebpiecesRulesConfig } from '@webpieces/rules-config';
+/** A rule config class usable as an inversify inject-by-type token. */
+export type ConfigCtor = new () => BaseRuleConfig;
+/**
+ * The 1:1 table of `[config class, webpieces.config.json rule key]`. The composition root iterates it
+ * to bind each rule's config into the container (`bind(ConfigClass).toConstantValue(config[key] ??
+ * new ConfigClass())`), so every `@provideSingleton` validator injects its config by type. Data only
+ * — the binding loop lives inline in the bin (an inline loop, exempt from no-function-outside-class).
+ */
+export declare const CONFIG_BINDINGS: ReadonlyArray<readonly [ConfigCtor, keyof WebpiecesRulesConfig]>;

package/src/code-rules-config-table.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_BINDINGS = void 0;
+const rules_config_1 = require("@webpieces/rules-config");
+/**
+ * The 1:1 table of `[config class, webpieces.config.json rule key]`. The composition root iterates it
+ * to bind each rule's config into the container (`bind(ConfigClass).toConstantValue(config[key] ??
+ * new ConfigClass())`), so every `@provideSingleton` validator injects its config by type. Data only
+ * — the binding loop lives inline in the bin (an inline loop, exempt from no-function-outside-class).
+ */
+exports.CONFIG_BINDINGS = [
+    [rules_config_1.MaxMethodLinesConfig, 'max-method-lines'],
+    [rules_config_1.MaxFileLinesConfig, 'max-file-lines'],
+    [rules_config_1.RequireReturnTypeConfig, 'require-return-type'],
+    [rules_config_1.NoInlineTypeLiteralsConfig, 'no-inline-type-literals'],
+    [rules_config_1.NoAnyUnknownConfig, 'no-any-unknown'],
+    [rules_config_1.NoImplicitAnyConfig, 'no-implicit-any'],
+    [rules_config_1.PrismaValidateDtosConfig, 'prisma-validate-dtos'],
+    [rules_config_1.PrismaConverterConfig, 'prisma-converter'],
+    [rules_config_1.NoDestructureConfig, 'no-destructure'],
+    [rules_config_1.CatchErrorPatternConfig, 'catch-error-pattern'],
+    [rules_config_1.NoUnmanagedExceptionsConfig, 'no-unmanaged-exceptions'],
+    [rules_config_1.AngularNoDirectApiInResolverConfig, 'angular-no-direct-api-in-resolver'],
+    [rules_config_1.NoSymbolDiTokensConfig, 'no-symbol-di-tokens'],
+    [rules_config_1.NoProcessExitOutsideMainConfig, 'no-process-exit-outside-main'],
+    [rules_config_1.NoFunctionOutsideClassConfig, 'no-function-outside-class'],
+    [rules_config_1.InjectAnnotationNotNeededForConcreteClassConfig, 'inject-annotation-not-needed-for-concrete-class'],
+    [rules_config_1.FrameworkTagConfig, 'framework-tag'],
+    [rules_config_1.RoleTagConfig, 'role-tag'],
+];
+//# sourceMappingURL=code-rules-config-table.js.map

package/src/code-rules-config-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-rules-config-table.js","sourceRoot":"","sources":["../../../../../packages/tooling/code-rules/src/code-rules-config-table.ts"],"names":[],"mappings":";;;AAAA,0DAqBiC;AAKjC;;;;;GAKG;AACU,QAAA,eAAe,GAAqE;IAC7F,CAAC,mCAAoB,EAAE,kBAAkB,CAAC;IAC1C,CAAC,iCAAkB,EAAE,gBAAgB,CAAC;IACtC,CAAC,sCAAuB,EAAE,qBAAqB,CAAC;IAChD,CAAC,yCAA0B,EAAE,yBAAyB,CAAC;IACvD,CAAC,iCAAkB,EAAE,gBAAgB,CAAC;IACtC,CAAC,kCAAmB,EAAE,iBAAiB,CAAC;IACxC,CAAC,uCAAwB,EAAE,sBAAsB,CAAC;IAClD,CAAC,oCAAqB,EAAE,kBAAkB,CAAC;IAC3C,CAAC,kCAAmB,EAAE,gBAAgB,CAAC;IACvC,CAAC,sCAAuB,EAAE,qBAAqB,CAAC;IAChD,CAAC,0CAA2B,EAAE,yBAAyB,CAAC;IACxD,CAAC,iDAAkC,EAAE,mCAAmC,CAAC;IACzE,CAAC,qCAAsB,EAAE,qBAAqB,CAAC;IAC/C,CAAC,6CAA8B,EAAE,8BAA8B,CAAC;IAChE,CAAC,2CAA4B,EAAE,2BAA2B,CAAC;IAC3D,CAAC,8DAA+C,EAAE,iDAAiD,CAAC;IACpG,CAAC,iCAAkB,EAAE,eAAe,CAAC;IACrC,CAAC,4BAAa,EAAE,UAAU,CAAC;CAC9B,CAAC","sourcesContent":["import {\n    BaseRuleConfig,\n    WebpiecesRulesConfig,\n    MaxMethodLinesConfig,\n    MaxFileLinesConfig,\n    RequireReturnTypeConfig,\n    NoInlineTypeLiteralsConfig,\n    NoAnyUnknownConfig,\n    NoImplicitAnyConfig,\n    PrismaValidateDtosConfig,\n    PrismaConverterConfig,\n    NoDestructureConfig,\n    CatchErrorPatternConfig,\n    NoUnmanagedExceptionsConfig,\n    AngularNoDirectApiInResolverConfig,\n    NoSymbolDiTokensConfig,\n    NoProcessExitOutsideMainConfig,\n    NoFunctionOutsideClassConfig,\n    InjectAnnotationNotNeededForConcreteClassConfig,\n    FrameworkTagConfig,\n    RoleTagConfig,\n} from '@webpieces/rules-config';\n\n/** A rule config class usable as an inversify inject-by-type token. */\nexport type ConfigCtor = new () => BaseRuleConfig;\n\n/**\n * The 1:1 table of `[config class, webpieces.config.json rule key]`. The composition root iterates it\n * to bind each rule's config into the container (`bind(ConfigClass).toConstantValue(config[key] ??\n * new ConfigClass())`), so every `@provideSingleton` validator injects its config by type. Data only\n * — the binding loop lives inline in the bin (an inline loop, exempt from no-function-outside-class).\n */\nexport const CONFIG_BINDINGS: ReadonlyArray<readonly [ConfigCtor, keyof WebpiecesRulesConfig]> = [\n    [MaxMethodLinesConfig, 'max-method-lines'],\n    [MaxFileLinesConfig, 'max-file-lines'],\n    [RequireReturnTypeConfig, 'require-return-type'],\n    [NoInlineTypeLiteralsConfig, 'no-inline-type-literals'],\n    [NoAnyUnknownConfig, 'no-any-unknown'],\n    [NoImplicitAnyConfig, 'no-implicit-any'],\n    [PrismaValidateDtosConfig, 'prisma-validate-dtos'],\n    [PrismaConverterConfig, 'prisma-converter'],\n    [NoDestructureConfig, 'no-destructure'],\n    [CatchErrorPatternConfig, 'catch-error-pattern'],\n    [NoUnmanagedExceptionsConfig, 'no-unmanaged-exceptions'],\n    [AngularNoDirectApiInResolverConfig, 'angular-no-direct-api-in-resolver'],\n    [NoSymbolDiTokensConfig, 'no-symbol-di-tokens'],\n    [NoProcessExitOutsideMainConfig, 'no-process-exit-outside-main'],\n    [NoFunctionOutsideClassConfig, 'no-function-outside-class'],\n    [InjectAnnotationNotNeededForConcreteClassConfig, 'inject-annotation-not-needed-for-concrete-class'],\n    [FrameworkTagConfig, 'framework-tag'],\n    [RoleTagConfig, 'role-tag'],\n];\n"]}

package/src/code-rules-context.d.ts

@@ -0,0 +1,19 @@
+import { MatchRuleConfig } from '@webpieces/rules-config';
+/**
+ * The resolved repo/workspace root, bound at bootstrap (toConstantValue) and injected where the
+ * engine runs validators. A tiny holder class so it is a normal inject-by-type DI node, not a raw
+ * string threaded through constructors.
+ */
+export declare class WorkspaceRoot {
+    readonly path: string;
+    constructor(path: string);
+}
+/**
+ * The client-authored match-rules (one validator gets built per entry). Bound at bootstrap so the
+ * engine can construct a MatchRulesValidator per config without the config classes leaking into
+ * every constructor.
+ */
+export declare class MatchRulesHolder {
+    readonly rules: readonly MatchRuleConfig[];
+    constructor(rules: readonly MatchRuleConfig[]);
+}

package/src/code-rules-context.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchRulesHolder = exports.WorkspaceRoot = void 0;
+/**
+ * The resolved repo/workspace root, bound at bootstrap (toConstantValue) and injected where the
+ * engine runs validators. A tiny holder class so it is a normal inject-by-type DI node, not a raw
+ * string threaded through constructors.
+ */
+class WorkspaceRoot {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+}
+exports.WorkspaceRoot = WorkspaceRoot;
+/**
+ * The client-authored match-rules (one validator gets built per entry). Bound at bootstrap so the
+ * engine can construct a MatchRulesValidator per config without the config classes leaking into
+ * every constructor.
+ */
+class MatchRulesHolder {
+    rules;
+    constructor(rules) {
+        this.rules = rules;
+    }
+}
+exports.MatchRulesHolder = MatchRulesHolder;
+//# sourceMappingURL=code-rules-context.js.map

package/src/code-rules-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-rules-context.js","sourceRoot":"","sources":["../../../../../packages/tooling/code-rules/src/code-rules-context.ts"],"names":[],"mappings":";;;AAEA;;;;GAIG;AACH,MAAa,aAAa;IACD;IAArB,YAAqB,IAAY;QAAZ,SAAI,GAAJ,IAAI,CAAQ;IAAG,CAAC;CACxC;AAFD,sCAEC;AAED;;;;GAIG;AACH,MAAa,gBAAgB;IACJ;IAArB,YAAqB,KAAiC;QAAjC,UAAK,GAAL,KAAK,CAA4B;IAAG,CAAC;CAC7D;AAFD,4CAEC","sourcesContent":["import { MatchRuleConfig } from '@webpieces/rules-config';\n\n/**\n * The resolved repo/workspace root, bound at bootstrap (toConstantValue) and injected where the\n * engine runs validators. A tiny holder class so it is a normal inject-by-type DI node, not a raw\n * string threaded through constructors.\n */\nexport class WorkspaceRoot {\n    constructor(readonly path: string) {}\n}\n\n/**\n * The client-authored match-rules (one validator gets built per entry). Bound at bootstrap so the\n * engine can construct a MatchRulesValidator per config without the config classes leaking into\n * every constructor.\n */\nexport class MatchRulesHolder {\n    constructor(readonly rules: readonly MatchRuleConfig[]) {}\n}\n"]}

package/src/code-rules-engine.d.ts

@@ -0,0 +1,67 @@
+import { ExecutorResult } from './code-validator';
+import { RuleReporter } from './rule-reporter';
+import { WorkspaceRoot, MatchRulesHolder } from './code-rules-context';
+import { MatchRulesChecker } from './validate-match-rules';
+import { MaxMethodLinesValidator } from './validate-modified-methods';
+import { MaxFileLinesValidator } from './validate-modified-files';
+import { RequireReturnTypeValidator } from './validate-return-types';
+import { NoInlineTypeLiteralsValidator } from './validate-no-inline-types';
+import { NoAnyUnknownValidator } from './validate-no-any-unknown';
+import { NoImplicitAnyValidator } from './validate-no-implicit-any';
+import { PrismaValidateDtosValidator } from './validate-dtos';
+import { PrismaConverterValidator } from './validate-prisma-converters';
+import { NoDestructureValidator } from './validate-no-destructure';
+import { CatchErrorPatternValidator } from './validate-catch-error-pattern';
+import { NoUnmanagedExceptionsValidator } from './validate-no-unmanaged-exceptions';
+import { NoDirectApiResolverValidator } from './validate-no-direct-api-resolver';
+import { NoSymbolDiTokensValidator } from './validate-no-symbol-di-tokens';
+import { NoProcessExitOutsideMainValidator } from './validate-no-process-exit-outside-main';
+import { NoFunctionOutsideClassValidator } from './validate-no-function-outside-class';
+import { InjectAnnotationNotNeededForConcreteClassValidator } from './validate-inject-annotation-not-needed-for-concrete-class';
+import { FrameworkTagValidator } from './validate-framework-tag';
+import { RoleTagValidator } from './validate-role-tag';
+/**
+ * Owns running the code-rules suite. Every built-in validator is injected as a singleton (its config
+ * is bound in the container at bootstrap), so this class IS the code-rules DI DAG the design graph
+ * draws. The per-entry match-rules validators are the one exception — they are config-per-instance,
+ * so they are built from the injected {@link MatchRulesHolder}.
+ */
+export declare class CodeRulesEngine {
+    private readonly workspace;
+    private readonly reporter;
+    private readonly matchRules;
+    private readonly matchChecker;
+    private readonly maxMethodLines;
+    private readonly maxFileLines;
+    private readonly requireReturnType;
+    private readonly noInlineTypeLiterals;
+    private readonly noAnyUnknown;
+    private readonly noImplicitAny;
+    private readonly prismaValidateDtos;
+    private readonly prismaConverter;
+    private readonly noDestructure;
+    private readonly catchErrorPattern;
+    private readonly noUnmanagedExceptions;
+    private readonly noDirectApiResolver;
+    private readonly noSymbolDiTokens;
+    private readonly noProcessExitOutsideMain;
+    private readonly noFunctionOutsideClass;
+    private readonly injectAnnotationNotNeeded;
+    private readonly frameworkTag;
+    private readonly roleTag;
+    constructor(workspace: WorkspaceRoot, reporter: RuleReporter, matchRules: MatchRulesHolder, matchChecker: MatchRulesChecker, maxMethodLines: MaxMethodLinesValidator, maxFileLines: MaxFileLinesValidator, requireReturnType: RequireReturnTypeValidator, noInlineTypeLiterals: NoInlineTypeLiteralsValidator, noAnyUnknown: NoAnyUnknownValidator, noImplicitAny: NoImplicitAnyValidator, prismaValidateDtos: PrismaValidateDtosValidator, prismaConverter: PrismaConverterValidator, noDestructure: NoDestructureValidator, catchErrorPattern: CatchErrorPatternValidator, noUnmanagedExceptions: NoUnmanagedExceptionsValidator, noDirectApiResolver: NoDirectApiResolverValidator, noSymbolDiTokens: NoSymbolDiTokensValidator, noProcessExitOutsideMain: NoProcessExitOutsideMainValidator, noFunctionOutsideClass: NoFunctionOutsideClassValidator, injectAnnotationNotNeeded: InjectAnnotationNotNeededForConcreteClassValidator, frameworkTag: FrameworkTagValidator, roleTag: RoleTagValidator);
+    /** The 18 injected built-in validators, in run order. */
+    private builtIns;
+    /**
+     * Every ACTIVE run: an injected built-in validator whose `shouldRun()` is true, or an injected
+     * match-rule check per configured entry that is active. Built as {@link RuleRun} value objects
+     * (name + thunk) so NO DAG member is `new`-ed — the validators and the checker are injected.
+     */
+    private activeRuns;
+    /**
+     * Run all configured code validators against the workspace. A validator runs only when
+     * `shouldRun()` is true (mode not OFF and no branch/epoch escape hatch). Per-run isolation lives
+     * in {@link RuleReporter} so one validator can never abort the rest.
+     */
+    run(): Promise<ExecutorResult>;
+}

package/src/code-rules-engine.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeRulesEngine = void 0;
+const tslib_1 = require("tslib");
+const core_context_1 = require("@webpieces/core-context");
+const inversify_1 = require("inversify");
+const code_validator_1 = require("./code-validator");
+const rule_reporter_1 = require("./rule-reporter");
+const code_rules_context_1 = require("./code-rules-context");
+const validate_match_rules_1 = require("./validate-match-rules");
+const validate_modified_methods_1 = require("./validate-modified-methods");
+const validate_modified_files_1 = require("./validate-modified-files");
+const validate_return_types_1 = require("./validate-return-types");
+const validate_no_inline_types_1 = require("./validate-no-inline-types");
+const validate_no_any_unknown_1 = require("./validate-no-any-unknown");
+const validate_no_implicit_any_1 = require("./validate-no-implicit-any");
+const validate_dtos_1 = require("./validate-dtos");
+const validate_prisma_converters_1 = require("./validate-prisma-converters");
+const validate_no_destructure_1 = require("./validate-no-destructure");
+const validate_catch_error_pattern_1 = require("./validate-catch-error-pattern");
+const validate_no_unmanaged_exceptions_1 = require("./validate-no-unmanaged-exceptions");
+const validate_no_direct_api_resolver_1 = require("./validate-no-direct-api-resolver");
+const validate_no_symbol_di_tokens_1 = require("./validate-no-symbol-di-tokens");
+const validate_no_process_exit_outside_main_1 = require("./validate-no-process-exit-outside-main");
+const validate_no_function_outside_class_1 = require("./validate-no-function-outside-class");
+const validate_inject_annotation_not_needed_for_concrete_class_1 = require("./validate-inject-annotation-not-needed-for-concrete-class");
+const validate_framework_tag_1 = require("./validate-framework-tag");
+const validate_role_tag_1 = require("./validate-role-tag");
+/**
+ * Owns running the code-rules suite. Every built-in validator is injected as a singleton (its config
+ * is bound in the container at bootstrap), so this class IS the code-rules DI DAG the design graph
+ * draws. The per-entry match-rules validators are the one exception — they are config-per-instance,
+ * so they are built from the injected {@link MatchRulesHolder}.
+ */
+let CodeRulesEngine = class CodeRulesEngine {
+    workspace;
+    reporter;
+    matchRules;
+    matchChecker;
+    maxMethodLines;
+    maxFileLines;
+    requireReturnType;
+    noInlineTypeLiterals;
+    noAnyUnknown;
+    noImplicitAny;
+    prismaValidateDtos;
+    prismaConverter;
+    noDestructure;
+    catchErrorPattern;
+    noUnmanagedExceptions;
+    noDirectApiResolver;
+    noSymbolDiTokens;
+    noProcessExitOutsideMain;
+    noFunctionOutsideClass;
+    injectAnnotationNotNeeded;
+    frameworkTag;
+    roleTag;
+    // webpieces-disable max-lines-new-methods -- the built-in validator set is flat; each is one injected field
+    constructor(workspace, reporter, matchRules, matchChecker, maxMethodLines, maxFileLines, requireReturnType, noInlineTypeLiterals, noAnyUnknown, noImplicitAny, prismaValidateDtos, prismaConverter, noDestructure, catchErrorPattern, noUnmanagedExceptions, noDirectApiResolver, noSymbolDiTokens, noProcessExitOutsideMain, noFunctionOutsideClass, injectAnnotationNotNeeded, frameworkTag, roleTag) {
+        this.workspace = workspace;
+        this.reporter = reporter;
+        this.matchRules = matchRules;
+        this.matchChecker = matchChecker;
+        this.maxMethodLines = maxMethodLines;
+        this.maxFileLines = maxFileLines;
+        this.requireReturnType = requireReturnType;
+        this.noInlineTypeLiterals = noInlineTypeLiterals;
+        this.noAnyUnknown = noAnyUnknown;
+        this.noImplicitAny = noImplicitAny;
+        this.prismaValidateDtos = prismaValidateDtos;
+        this.prismaConverter = prismaConverter;
+        this.noDestructure = noDestructure;
+        this.catchErrorPattern = catchErrorPattern;
+        this.noUnmanagedExceptions = noUnmanagedExceptions;
+        this.noDirectApiResolver = noDirectApiResolver;
+        this.noSymbolDiTokens = noSymbolDiTokens;
+        this.noProcessExitOutsideMain = noProcessExitOutsideMain;
+        this.noFunctionOutsideClass = noFunctionOutsideClass;
+        this.injectAnnotationNotNeeded = injectAnnotationNotNeeded;
+        this.frameworkTag = frameworkTag;
+        this.roleTag = roleTag;
+    }
+    /** The 18 injected built-in validators, in run order. */
+    builtIns() {
+        return [
+            this.maxMethodLines, this.maxFileLines, this.requireReturnType, this.noInlineTypeLiterals,
+            this.noAnyUnknown, this.noImplicitAny, this.prismaValidateDtos, this.prismaConverter,
+            this.noDestructure, this.catchErrorPattern, this.noUnmanagedExceptions, this.noDirectApiResolver,
+            this.noSymbolDiTokens, this.noProcessExitOutsideMain, this.noFunctionOutsideClass,
+            this.injectAnnotationNotNeeded, this.frameworkTag, this.roleTag,
+        ];
+    }
+    /**
+     * Every ACTIVE run: an injected built-in validator whose `shouldRun()` is true, or an injected
+     * match-rule check per configured entry that is active. Built as {@link RuleRun} value objects
+     * (name + thunk) so NO DAG member is `new`-ed — the validators and the checker are injected.
+     */
+    activeRuns(root) {
+        const runs = [];
+        for (const v of this.builtIns()) {
+            if (v.shouldRun())
+                runs.push(new code_validator_1.RuleRun(v.name, () => v.run(root)));
+        }
+        for (const mr of this.matchRules.rules) {
+            if (this.matchChecker.shouldRun(mr))
+                runs.push(new code_validator_1.RuleRun(mr.name, () => this.matchChecker.runForConfig(mr, root)));
+        }
+        return runs;
+    }
+    /**
+     * Run all configured code validators against the workspace. A validator runs only when
+     * `shouldRun()` is true (mode not OFF and no branch/epoch escape hatch). Per-run isolation lives
+     * in {@link RuleReporter} so one validator can never abort the rest.
+     */
+    async run() {
+        const runs = this.activeRuns(this.workspace.path);
+        if (runs.length === 0) {
+            console.log('\n⏭️  Skipping all code validations (all modes: OFF)\n');
+            return { success: true };
+        }
+        console.log('\n📏 Running Code Validations\n');
+        console.log(`   Active rules: ${runs.map((r) => r.name).join(', ')}`);
+        console.log('');
+        const result = await this.reporter.runValidators(runs);
+        console.log(result.success ? '\n✅ All code validations passed\n' : '\n❌ Some code validations failed\n');
+        return result;
+    }
+};
+exports.CodeRulesEngine = CodeRulesEngine;
+exports.CodeRulesEngine = CodeRulesEngine = tslib_1.__decorate([
+    (0, core_context_1.provideSingleton)(),
+    (0, inversify_1.injectable)(),
+    tslib_1.__metadata("design:paramtypes", [code_rules_context_1.WorkspaceRoot,
+        rule_reporter_1.RuleReporter,
+        code_rules_context_1.MatchRulesHolder,
+        validate_match_rules_1.MatchRulesChecker,
+        validate_modified_methods_1.MaxMethodLinesValidator,
+        validate_modified_files_1.MaxFileLinesValidator,
+        validate_return_types_1.RequireReturnTypeValidator,
+        validate_no_inline_types_1.NoInlineTypeLiteralsValidator,
+        validate_no_any_unknown_1.NoAnyUnknownValidator,
+        validate_no_implicit_any_1.NoImplicitAnyValidator,
+        validate_dtos_1.PrismaValidateDtosValidator,
+        validate_prisma_converters_1.PrismaConverterValidator,
+        validate_no_destructure_1.NoDestructureValidator,
+        validate_catch_error_pattern_1.CatchErrorPatternValidator,
+        validate_no_unmanaged_exceptions_1.NoUnmanagedExceptionsValidator,
+        validate_no_direct_api_resolver_1.NoDirectApiResolverValidator,
+        validate_no_symbol_di_tokens_1.NoSymbolDiTokensValidator,
+        validate_no_process_exit_outside_main_1.NoProcessExitOutsideMainValidator,
+        validate_no_function_outside_class_1.NoFunctionOutsideClassValidator,
+        validate_inject_annotation_not_needed_for_concrete_class_1.InjectAnnotationNotNeededForConcreteClassValidator,
+        validate_framework_tag_1.FrameworkTagValidator,
+        validate_role_tag_1.RoleTagValidator])
+], CodeRulesEngine);
+//# sourceMappingURL=code-rules-engine.js.map

package/src/code-rules-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-rules-engine.js","sourceRoot":"","sources":["../../../../../packages/tooling/code-rules/src/code-rules-engine.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseRuleConfig } from '@webpieces/rules-config';\nimport { provideSingleton } from '@webpieces/core-context';\nimport { injectable } from 'inversify';\n\nimport { CodeValidator, ExecutorResult, RuleRun } from './code-validator';\nimport { RuleReporter } from './rule-reporter';\nimport { WorkspaceRoot, MatchRulesHolder } from './code-rules-context';\nimport { MatchRulesChecker } from './validate-match-rules';\nimport { MaxMethodLinesValidator } from './validate-modified-methods';\nimport { MaxFileLinesValidator } from './validate-modified-files';\nimport { RequireReturnTypeValidator } from './validate-return-types';\nimport { NoInlineTypeLiteralsValidator } from './validate-no-inline-types';\nimport { NoAnyUnknownValidator } from './validate-no-any-unknown';\nimport { NoImplicitAnyValidator } from './validate-no-implicit-any';\nimport { PrismaValidateDtosValidator } from './validate-dtos';\nimport { PrismaConverterValidator } from './validate-prisma-converters';\nimport { NoDestructureValidator } from './validate-no-destructure';\nimport { CatchErrorPatternValidator } from './validate-catch-error-pattern';\nimport { NoUnmanagedExceptionsValidator } from './validate-no-unmanaged-exceptions';\nimport { NoDirectApiResolverValidator } from './validate-no-direct-api-resolver';\nimport { NoSymbolDiTokensValidator } from './validate-no-symbol-di-tokens';\nimport { NoProcessExitOutsideMainValidator } from './validate-no-process-exit-outside-main';\nimport { NoFunctionOutsideClassValidator } from './validate-no-function-outside-class';\nimport { InjectAnnotationNotNeededForConcreteClassValidator } from './validate-inject-annotation-not-needed-for-concrete-class';\nimport { FrameworkTagValidator } from './validate-framework-tag';\nimport { RoleTagValidator } from './validate-role-tag';\n\n/**\n * Owns running the code-rules suite. Every built-in validator is injected as a singleton (its config\n * is bound in the container at bootstrap), so this class IS the code-rules DI DAG the design graph\n * draws. The per-entry match-rules validators are the one exception — they are config-per-instance,\n * so they are built from the injected {@link MatchRulesHolder}.\n */\n@provideSingleton()\n@injectable()\nexport class CodeRulesEngine {\n    // webpieces-disable max-lines-new-methods -- the built-in validator set is flat; each is one injected field\n    constructor(\n        private readonly workspace: WorkspaceRoot,\n        private readonly reporter: RuleReporter,\n        private readonly matchRules: MatchRulesHolder,\n        private readonly matchChecker: MatchRulesChecker,\n        private readonly maxMethodLines: MaxMethodLinesValidator,\n        private readonly maxFileLines: MaxFileLinesValidator,\n        private readonly requireReturnType: RequireReturnTypeValidator,\n        private readonly noInlineTypeLiterals: NoInlineTypeLiteralsValidator,\n        private readonly noAnyUnknown: NoAnyUnknownValidator,\n        private readonly noImplicitAny: NoImplicitAnyValidator,\n        private readonly prismaValidateDtos: PrismaValidateDtosValidator,\n        private readonly prismaConverter: PrismaConverterValidator,\n        private readonly noDestructure: NoDestructureValidator,\n        private readonly catchErrorPattern: CatchErrorPatternValidator,\n        private readonly noUnmanagedExceptions: NoUnmanagedExceptionsValidator,\n        private readonly noDirectApiResolver: NoDirectApiResolverValidator,\n        private readonly noSymbolDiTokens: NoSymbolDiTokensValidator,\n        private readonly noProcessExitOutsideMain: NoProcessExitOutsideMainValidator,\n        private readonly noFunctionOutsideClass: NoFunctionOutsideClassValidator,\n        private readonly injectAnnotationNotNeeded: InjectAnnotationNotNeededForConcreteClassValidator,\n        private readonly frameworkTag: FrameworkTagValidator,\n        private readonly roleTag: RoleTagValidator,\n    ) {}\n\n    /** The 18 injected built-in validators, in run order. */\n    private builtIns(): CodeValidator<BaseRuleConfig>[] {\n        return [\n            this.maxMethodLines, this.maxFileLines, this.requireReturnType, this.noInlineTypeLiterals,\n            this.noAnyUnknown, this.noImplicitAny, this.prismaValidateDtos, this.prismaConverter,\n            this.noDestructure, this.catchErrorPattern, this.noUnmanagedExceptions, this.noDirectApiResolver,\n            this.noSymbolDiTokens, this.noProcessExitOutsideMain, this.noFunctionOutsideClass,\n            this.injectAnnotationNotNeeded, this.frameworkTag, this.roleTag,\n        ];\n    }\n\n    /**\n     * Every ACTIVE run: an injected built-in validator whose `shouldRun()` is true, or an injected\n     * match-rule check per configured entry that is active. Built as {@link RuleRun} value objects\n     * (name + thunk) so NO DAG member is `new`-ed — the validators and the checker are injected.\n     */\n    private activeRuns(root: string): RuleRun[] {\n        const runs: RuleRun[] = [];\n        for (const v of this.builtIns()) {\n            if (v.shouldRun()) runs.push(new RuleRun(v.name, () => v.run(root)));\n        }\n        for (const mr of this.matchRules.rules) {\n            if (this.matchChecker.shouldRun(mr)) runs.push(new RuleRun(mr.name, () => this.matchChecker.runForConfig(mr, root)));\n        }\n        return runs;\n    }\n\n    /**\n     * Run all configured code validators against the workspace. A validator runs only when\n     * `shouldRun()` is true (mode not OFF and no branch/epoch escape hatch). Per-run isolation lives\n     * in {@link RuleReporter} so one validator can never abort the rest.\n     */\n    async run(): Promise<ExecutorResult> {\n        const runs = this.activeRuns(this.workspace.path);\n        if (runs.length === 0) {\n            console.log('\\n⏭️  Skipping all code validations (all modes: OFF)\\n');\n            return { success: true };\n        }\n\n        console.log('\\n📏 Running Code Validations\\n');\n        console.log(`   Active rules: ${runs.map((r: RuleRun) => r.name).join(', ')}`);\n        console.log('');\n\n        const result = await this.reporter.runValidators(runs);\n        console.log(result.success ? '\\n✅ All code validations passed\\n' : '\\n❌ Some code validations failed\\n');\n        return result;\n    }\n}\n"]}

package/src/code-validator.d.ts

@@ -5,6 +5,16 @@ import { AbstractRule, BaseRuleConfig } from '@webpieces/rules-config';
 export interface ExecutorResult {
     success: boolean;
 }
+/**
+ * One named unit of work for {@link RuleReporter} — a validator (or a per-entry match-rule) paired
+ * with a thunk that runs it. A value object (not a DAG service), so the engine can build the run list
+ * from its injected validators + checker WITHOUT `new`-ing any DAG member.
+ */
+export declare class RuleRun {
+    readonly name: string;
+    readonly run: () => Promise<ExecutorResult>;
+    constructor(name: string, run: () => Promise<ExecutorResult>);
+}
 /**
  * Base class for every code-rules validator.
  *

package/src/code-validator.js

@@ -1,7 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeValidator = void 0;
+exports.CodeValidator = exports.RuleRun = void 0;
 const rules_config_1 = require("@webpieces/rules-config");
+/**
+ * One named unit of work for {@link RuleReporter} — a validator (or a per-entry match-rule) paired
+ * with a thunk that runs it. A value object (not a DAG service), so the engine can build the run list
+ * from its injected validators + checker WITHOUT `new`-ing any DAG member.
+ */
+class RuleRun {
+    name;
+    run;
+    constructor(name, run) {
+        this.name = name;
+        this.run = run;
+    }
+}
+exports.RuleRun = RuleRun;
 /**
  * Base class for every code-rules validator.
  *

package/src/code-validator.js.map

@@ -1 +1 @@
-{"version":3,"file":"code-validator.js","sourceRoot":"","sources":["../../../../../packages/tooling/code-rules/src/code-validator.ts"],"names":[],"mappings":";;;AAAA,0DAAuE;AASvE;;;;;;;GAOG;AACH,MAAsB,aAAwC,SAAQ,2BAAe;CAEpF;AAFD,sCAEC","sourcesContent":["import { AbstractRule, BaseRuleConfig } from '@webpieces/rules-config';\n\n/**\n * Result of running a single code validator.\n */\nexport interface ExecutorResult {\n    success: boolean;\n}\n\n/**\n * Base class for every code-rules validator.\n *\n * Extends the shared {@link AbstractRule} (which owns `name` + the on/off + escape-hatch\n * decision in `shouldRun()`) and adds the code-rules execution surface: `run(workspaceRoot)`.\n * Each validator is constructed with its typed `*Config` from `@webpieces/rules-config`, so\n * the config classes are genuinely consumed (find-usages / rename work across packages).\n */\nexport abstract class CodeValidator<C extends BaseRuleConfig> extends AbstractRule<C> {\n    abstract run(workspaceRoot: string): Promise<ExecutorResult>;\n}\n"]}
+{"version":3,"file":"code-validator.js","sourceRoot":"","sources":["../../../../../packages/tooling/code-rules/src/code-validator.ts"],"names":[],"mappings":";;;AAAA,0DAAuE;AASvE;;;;GAIG;AACH,MAAa,OAAO;IAEH;IACA;IAFb,YACa,IAAY,EACZ,GAAkC;QADlC,SAAI,GAAJ,IAAI,CAAQ;QACZ,QAAG,GAAH,GAAG,CAA+B;IAC5C,CAAC;CACP;AALD,0BAKC;AAED;;;;;;;GAOG;AACH,MAAsB,aAAwC,SAAQ,2BAAe;CAEpF;AAFD,sCAEC","sourcesContent":["import { AbstractRule, BaseRuleConfig } from '@webpieces/rules-config';\n\n/**\n * Result of running a single code validator.\n */\nexport interface ExecutorResult {\n    success: boolean;\n}\n\n/**\n * One named unit of work for {@link RuleReporter} — a validator (or a per-entry match-rule) paired\n * with a thunk that runs it. A value object (not a DAG service), so the engine can build the run list\n * from its injected validators + checker WITHOUT `new`-ing any DAG member.\n */\nexport class RuleRun {\n    constructor(\n        readonly name: string,\n        readonly run: () => Promise<ExecutorResult>,\n    ) {}\n}\n\n/**\n * Base class for every code-rules validator.\n *\n * Extends the shared {@link AbstractRule} (which owns `name` + the on/off + escape-hatch\n * decision in `shouldRun()`) and adds the code-rules execution surface: `run(workspaceRoot)`.\n * Each validator is constructed with its typed `*Config` from `@webpieces/rules-config`, so\n * the config classes are genuinely consumed (find-usages / rename work across packages).\n */\nexport abstract class CodeValidator<C extends BaseRuleConfig> extends AbstractRule<C> {\n    abstract run(workspaceRoot: string): Promise<ExecutorResult>;\n}\n"]}

package/src/rule-reporter.d.ts

@@ -1,12 +1,17 @@
-import { BaseRuleConfig } from '@webpieces/rules-config';
-import { CodeValidator, ExecutorResult } from './code-validator';
+import { RuleRun, ExecutorResult } from './code-validator';
 /**
- * Run every active validator with per-validator isolation: a validator that throws — a `RuleFailError`
- * (an expected failure) OR a plain `Error` (a bug) — is caught, reported, and marks the run failed,
- * but the remaining validators STILL run. One validator can no longer abort the whole CI run (the
- * previous raw loop had no per-validator try/catch, so a single bug aborted everything).
- *
- * Back-compatible: validators that still `console.error(...)` + `return { success: false }` keep
- * working; their `false` result flips the aggregate exactly as before.
+ * Runs the active validators with per-validator isolation and prints failures for humans/CI.
  */
-export declare function runValidators(active: readonly CodeValidator<BaseRuleConfig>[], workspaceRoot: string): Promise<ExecutorResult>;
+export declare class RuleReporter {
+    /**
+     * Run every {@link RuleRun} with per-run isolation: a run that throws — a `RuleFailError` (an
+     * expected failure) OR a plain `Error` (a bug) — is caught, reported, and marks the whole run
+     * failed, but the remaining runs STILL execute. One validator can no longer abort the CI run.
+     *
+     * Back-compatible: runs that still `console.error(...)` + `return { success: false }` keep
+     * working; their `false` result flips the aggregate exactly as before.
+     */
+    runValidators(runs: readonly RuleRun[]): Promise<ExecutorResult>;
+    private reportRuleFail;
+    private reportCrash;
+}