@gobing-ai/ts-rule-engine 0.3.1 → 0.3.3

package/src/engine.ts

@@ -1,4 +1,7 @@
+import type { EventBus, Logger } from '@gobing-ai/ts-infra';
+import { addSpanEvent, getLogger, traceAsync } from '@gobing-ai/ts-infra';
 import type { ProcessExecutor } from '@gobing-ai/ts-runtime';
+import type { RuleEngineEvents } from './events';
 import {
     applyFixes as applyFixesImpl,
     builtInFixers,
@@ -10,7 +13,7 @@ import {
 import { registerBuiltins } from './host/builtins';
 import { RuleEngineHost } from './host/rule-engine-host';
 import type { ConstraintFinding, ConstraintRule, Fix, FixMode, RuleEngineResult, RuleEvaluator } from './types';
-import { createFinding } from './types';
+import { createFinding, SEVERITY_RANK } from './types';
 
 /** Options for constructing a RuleEngine. */
 export interface RuleEngineOptions {
@@ -18,6 +21,10 @@ export interface RuleEngineOptions {
     processExecutor?: ProcessExecutor;
     /** Optional preconfigured host. */
     host?: RuleEngineHost;
+    /** Optional event bus for structured run observability (R-A4). */
+    events?: EventBus<RuleEngineEvents>;
+    /** Optional logger; defaults to the shared `rule-engine` category logger. */
+    logger?: Logger;
 }
 
 /** Orchestrates enabled constraint rules through a typed evaluator host. */
@@ -27,11 +34,15 @@ export class RuleEngine {
 
     /** Fixer providers keyed by evaluator type. */
     private readonly fixers: Map<string, RuleFixerProvider>;
+    private readonly events: EventBus<RuleEngineEvents> | undefined;
+    private readonly logger: Logger;
 
     constructor(options: RuleEngineOptions = {}) {
         this.host = options.host ?? new RuleEngineHost();
         registerBuiltins(this.host, options.processExecutor);
         this.fixers = builtInFixers(this.host, options.processExecutor);
+        this.events = options.events;
+        this.logger = options.logger ?? getLogger('rule-engine');
     }
 
     /** Register or replace an evaluator. */
@@ -47,8 +58,12 @@ export class RuleEngine {
      * findings, never auto-generated fixes. Keeps the rule loop and error-finding
      * semantics in one place.
      */
-    async evaluate(rules: ConstraintRule[], workdir: string): Promise<RuleEngineResult> {
-        return this.evaluateWithFixes(rules, workdir, 'none');
+    async evaluate(
+        rules: ConstraintRule[],
+        workdir: string,
+        stopOnFirst?: 'error' | 'warning' | 'info',
+    ): Promise<RuleEngineResult> {
+        return this.evaluateWithFixes(rules, workdir, 'none', stopOnFirst);
     }
 
     /**
@@ -61,60 +76,130 @@ export class RuleEngine {
      * @param rules - Normalized rule definitions to evaluate.
      * @param workdir - Working directory to scan.
      * @param maxFixMode - Highest fix authority requested by the caller.
+     * @param stopOnFirst - When set, stop evaluating rules after the first rule
+     *   whose findings meet/exceed this severity threshold. Undefined = exhaustive
+     *   (today's behavior, zero breaking change).
      * @returns Findings plus fixes allowed by the requested authority.
      */
     async evaluateWithFixes(
         rules: ConstraintRule[],
         workdir: string,
         maxFixMode: FixMode = 'auto',
+        stopOnFirst?: 'error' | 'warning' | 'info',
     ): Promise<RuleEngineResult> {
-        const findings: ConstraintFinding[] = [];
-        const fixes: Fix[] = [];
-
-        for (const rule of rules) {
-            if (rule.enabled === false) continue;
-
-            let ruleFindings: ConstraintFinding[] = [];
-            let ruleEvalFixes: Fix[] = [];
-            try {
-                const result = await this.host.evaluators.get(rule.evaluator.type).evaluate(rule, { rule, workdir });
-                ruleFindings = result.findings;
-                ruleEvalFixes = result.fixes;
-            } catch (error) {
-                ruleFindings = [
-                    createFinding(rule, error instanceof Error ? error.message : String(error), null, {
-                        code: `evaluator:${rule.evaluator.type}`,
-                        kind: 'error',
-                    }),
-                ];
-            }
-
-            findings.push(...ruleFindings);
-            fixes.push(...ruleEvalFixes);
-
-            const ruleMode = rule.fix?.mode ?? 'none';
-            const effectiveMode = effectiveFixMode(ruleMode, maxFixMode);
-
-            if (effectiveMode !== 'none' && ruleFindings.length > 0) {
-                const provider = this.fixers.get(rule.evaluator.type);
-                if (provider) {
-                    const effectiveFix: EffectiveFix = {
-                        mode: effectiveMode,
-                        ...(rule.fix?.replacement !== undefined ? { replacement: rule.fix.replacement } : {}),
-                        ...(rule.fix?.params !== undefined ? { params: rule.fix.params } : {}),
-                    };
-                    const providerFixes = await provider.createFixes({
-                        rule,
-                        context: { rule, workdir },
-                        findings: ruleFindings,
-                        fix: effectiveFix,
+        const enabledRules = rules.filter((r) => r.enabled !== false);
+        const runStartMs = Date.now();
+
+        return await traceAsync(
+            'rule.run',
+            async () => {
+                this.logger.info('rule run started', { enabled: enabledRules.length, total: rules.length });
+                addSpanEvent('rule.run.start', { rules: enabledRules.length, total: rules.length });
+                void this.events?.emit('rule.run.start', { rules: enabledRules.length, total: rules.length });
+
+                const findings: ConstraintFinding[] = [];
+                const fixes: Fix[] = [];
+                let index = 0;
+                let stoppedEarlyLocal = false;
+
+                for (const rule of rules) {
+                    if (rule.enabled === false) continue;
+                    index++;
+
+                    const evalStartMs = Date.now();
+                    this.logger.debug('eval start', { ruleId: rule.id, index, total: enabledRules.length });
+                    addSpanEvent('rule.eval.start', { ruleId: rule.id, index, total: enabledRules.length });
+                    void this.events?.emit('rule.eval.start', { ruleId: rule.id, index, total: enabledRules.length });
+
+                    let ruleFindings: ConstraintFinding[] = [];
+                    let ruleEvalFixes: Fix[] = [];
+                    try {
+                        const result = await this.host.evaluators
+                            .get(rule.evaluator.type)
+                            .evaluate(rule, { rule, workdir });
+                        ruleFindings = result.findings;
+                        ruleEvalFixes = result.fixes;
+                    } catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        ruleFindings = [
+                            createFinding(rule, message, null, {
+                                code: `evaluator:${rule.evaluator.type}`,
+                                kind: 'error',
+                            }),
+                        ];
+                        addSpanEvent('rule.eval.error', { ruleId: rule.id, error: message });
+                        void this.events?.emit('rule.eval.error', { ruleId: rule.id, error: message });
+                    }
+
+                    const durationMs = Date.now() - evalStartMs;
+                    addSpanEvent('rule.eval.done', {
+                        ruleId: rule.id,
+                        findings: ruleFindings.length,
+                        durationMs,
+                    });
+                    void this.events?.emit('rule.eval.done', {
+                        ruleId: rule.id,
+                        findings: ruleFindings.length,
+                        durationMs,
                     });
-                    fixes.push(...providerFixes);
+
+                    findings.push(...ruleFindings);
+                    fixes.push(...ruleEvalFixes);
+
+                    const ruleMode = rule.fix?.mode ?? 'none';
+                    const effectiveMode = effectiveFixMode(ruleMode, maxFixMode);
+
+                    if (effectiveMode !== 'none' && ruleFindings.length > 0) {
+                        const provider = this.fixers.get(rule.evaluator.type);
+                        if (provider) {
+                            const effectiveFix: EffectiveFix = {
+                                mode: effectiveMode,
+                                ...(rule.fix?.replacement !== undefined ? { replacement: rule.fix.replacement } : {}),
+                                ...(rule.fix?.params !== undefined ? { params: rule.fix.params } : {}),
+                            };
+                            const providerFixes = await provider.createFixes({
+                                rule,
+                                context: { rule, workdir },
+                                findings: ruleFindings,
+                                fix: effectiveFix,
+                            });
+                            fixes.push(...providerFixes);
+                        }
+                    }
+
+                    if (
+                        stopOnFirst &&
+                        ruleFindings.some((f) => SEVERITY_RANK[f.severity] >= SEVERITY_RANK[stopOnFirst])
+                    ) {
+                        stoppedEarlyLocal = true;
+                        break;
+                    }
                 }
-            }
-        }
 
-        return { findings, fixes };
+                const runDurationMs = Date.now() - runStartMs;
+                this.logger.info('rule run done', {
+                    rules: enabledRules.length,
+                    findings: findings.length,
+                    durationMs: runDurationMs,
+                    stoppedEarly: stoppedEarlyLocal,
+                });
+                addSpanEvent('rule.run.done', {
+                    rules: enabledRules.length,
+                    findings: findings.length,
+                    durationMs: runDurationMs,
+                    stoppedEarly: stoppedEarlyLocal,
+                });
+                void this.events?.emit('rule.run.done', {
+                    rules: enabledRules.length,
+                    findings: findings.length,
+                    durationMs: runDurationMs,
+                    stoppedEarly: stoppedEarlyLocal,
+                });
+
+                return { findings, fixes };
+            },
+            { attributes: { 'rule.count': enabledRules.length } },
+        );
     }
 
     /**

package/src/evaluators/agent-detection-evaluator.ts

@@ -6,6 +6,7 @@ import {
     type RuleEvaluationResult,
     type RuleEvaluator,
 } from '../types';
+import { configArray } from './file-utils';
 
 /** Evaluates local availability of configured coding agents. */
 export class AgentDetectionEvaluator implements RuleEvaluator {
@@ -13,7 +14,7 @@ export class AgentDetectionEvaluator implements RuleEvaluator {
 
     /** Probe required agents and emit findings for missing CLIs. */
     async evaluate(rule: ConstraintRule, _context: RuleContext): Promise<RuleEvaluationResult> {
-        const agents = arrayConfig(rule.evaluator.config ?? {}, 'agents');
+        const agents = configArray(rule.evaluator.config ?? {}, 'agents', undefined, { evaluator: 'agent-detection' });
         const findings = [];
         for (const agent of agents) {
             if (!isAgentName(agent)) {
@@ -28,10 +29,3 @@ export class AgentDetectionEvaluator implements RuleEvaluator {
         return { findings, fixes: [] };
     }
 }
-
-function arrayConfig(config: Record<string, unknown>, key: string): string[] {
-    const value = config[key];
-    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value;
-    if (typeof value === 'string') return [value];
-    throw new Error(`agent-detection evaluator requires string[] config "${key}"`);
-}

package/src/evaluators/coverage-gate-evaluator.ts

@@ -1,5 +1,4 @@
-import { isAbsolute, relative, resolve } from 'node:path';
-import { NodeFileSystem } from '@gobing-ai/ts-runtime';
+import { isAbsolutePath, NodeFileSystem, relativePath, resolvePath } from '@gobing-ai/ts-runtime';
 import {
     type ConstraintRule,
     createFinding,
@@ -55,8 +54,8 @@ export class CoverageGateEvaluator implements RuleEvaluator {
     async evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult> {
         const config = (rule.evaluator.config ?? {}) as CoverageGateConfig;
         const lcovPath = config.lcovPath
-            ? resolve(context.workdir, config.lcovPath)
-            : resolve(context.workdir, 'coverage', 'lcov.info');
+            ? resolvePath(context.workdir, config.lcovPath)
+            : resolvePath(context.workdir, 'coverage', 'lcov.info');
 
         if (!(await this.fs.exists(lcovPath))) {
             return {
@@ -142,6 +141,6 @@ function isAlwaysExcluded(filePath: string): boolean {
 
 /** Normalize an lcov `SF:` path to a workdir-relative forward-slash path. */
 function normalizeLcovSourcePath(workdir: string, filePath: string): string {
-    const normalized = isAbsolute(filePath) ? relative(workdir, filePath) : filePath;
+    const normalized = isAbsolutePath(filePath) ? relativePath(workdir, filePath) : filePath;
     return normalized.replaceAll('\\', '/');
 }

package/src/evaluators/exit-code-evaluator.ts

@@ -6,6 +6,7 @@ import {
     type RuleEvaluationResult,
     type RuleEvaluator,
 } from '../types';
+import { configArray, configNumber, configString } from './file-utils';
 
 /** Evaluates a rule by running a subprocess and checking its exit code. */
 export class ExitCodeEvaluator implements RuleEvaluator {
@@ -14,10 +15,10 @@ export class ExitCodeEvaluator implements RuleEvaluator {
     /** Run configured command and emit a finding unless the exit code matches `successCode`. */
     async evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult> {
         const config = rule.evaluator.config ?? {};
-        const command = stringConfig(config, 'command');
-        const args = arrayConfig(config, 'args', []);
-        const successCode = numberConfig(config, 'successCode', 0);
-        const timeout = numberConfig(config, 'timeout', 60_000);
+        const command = configString(config, 'command', undefined, { evaluator: 'exit-code' });
+        const args = configArray(config, 'args', []);
+        const successCode = configNumber(config, 'successCode', 0);
+        const timeout = configNumber(config, 'timeout', 60_000);
         const result = await this.executor.run({
             command,
             args,
@@ -28,7 +29,7 @@ export class ExitCodeEvaluator implements RuleEvaluator {
         });
         if (result.exitCode === successCode) return { findings: [], fixes: [] };
 
-        const template = stringConfig(
+        const template = configString(
             config,
             'message',
             `Command failed (exit {code}): ${command} ${args.join(' ')}`.trim(),
@@ -40,21 +41,3 @@ export class ExitCodeEvaluator implements RuleEvaluator {
         };
     }
 }
-
-function numberConfig(config: Record<string, unknown>, key: string, fallback: number): number {
-    const value = config[key];
-    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
-}
-
-function stringConfig(config: Record<string, unknown>, key: string, fallback?: string): string {
-    const value = config[key];
-    if (typeof value === 'string') return value;
-    if (fallback !== undefined) return fallback;
-    throw new Error(`exit-code evaluator requires string config "${key}"`);
-}
-
-function arrayConfig(config: Record<string, unknown>, key: string, fallback: string[]): string[] {
-    const value = config[key];
-    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value;
-    return fallback;
-}

package/src/evaluators/file-utils.ts

@@ -1,5 +1,11 @@
-import { dirname, relative, resolve } from 'node:path';
-import { type FileSystem, NodeFileSystem, walkDir } from '@gobing-ai/ts-runtime';
+import {
+    dirnamePath,
+    type LegacyFileSystem as FileSystem,
+    NodeFileSystem,
+    relativePath,
+    resolvePath,
+    walkDir,
+} from '@gobing-ai/ts-runtime';
 
 /** Options for source-file discovery. */
 export interface SourceDiscoveryOptions {
@@ -13,14 +19,19 @@ export interface SourceDiscoveryOptions {
     fs?: FileSystem;
 }
 
-const DEFAULT_EXCLUDES = new Set(['.git', 'node_modules', 'dist', '.coverage', '.astro', '.wrangler']);
+/**
+ * Directory names pruned from every file walk — heavy or generated trees that no rule
+ * should scan. Shared so subprocess-backed evaluators (e.g. `sg`) can forward the same
+ * skip-list to the external tool instead of relying on each rule to remember it.
+ */
+export const DEFAULT_EXCLUDES = new Set(['.git', 'node_modules', 'dist', '.coverage', '.astro', '.wrangler']);
 
 /** Resolve source files for evaluators using conservative path-fragment matching. */
 export async function discoverFiles(options: SourceDiscoveryOptions): Promise<string[]> {
     const fs = options.fs ?? new NodeFileSystem();
-    const allFiles = await walkDir(options.workdir, fs);
+    const allFiles = await walkDir(options.workdir, fs, DEFAULT_EXCLUDES);
     return allFiles
-        .map((path) => relative(options.workdir, path))
+        .map((path) => relativePath(options.workdir, path))
         .filter((path) => !path.split('/').some((segment) => DEFAULT_EXCLUDES.has(segment)))
         .filter(
             (path) =>
@@ -31,7 +42,7 @@ export async function discoverFiles(options: SourceDiscoveryOptions): Promise<st
 
 /** Read a file from a workdir-relative path. */
 export async function readWorkdirFile(workdir: string, filePath: string, fs = new NodeFileSystem()): Promise<string> {
-    return await fs.readFile(resolve(workdir, filePath));
+    return await fs.readFile(resolvePath(workdir, filePath));
 }
 
 /** A discovered in-scope file paired with its contents. */
@@ -104,12 +115,12 @@ async function discoverFilesByGlob(
 
 /** Ensure a path is workdir-relative for findings. */
 export function relativeToWorkdir(workdir: string, path: string): string {
-    return relative(workdir, resolve(path));
+    return relativePath(workdir, resolvePath(path));
 }
 
 /** Return parent directory for a workdir-relative path. */
 export function relativeParent(path: string): string {
-    const parent = dirname(path);
+    const parent = dirnamePath(path);
     return parent === '.' ? '' : parent;
 }
 
@@ -170,6 +181,57 @@ export function stringArray(value: unknown): string[] | undefined {
     return Array.isArray(value) && value.every((item) => typeof item === 'string') ? (value as string[]) : undefined;
 }
 
+/** Optional accessor context — names the evaluator in "required config" errors for rule authors. */
+export interface ConfigAccessorOptions {
+    /** Evaluator name surfaced in the error, e.g. `"regex evaluator requires string config \"pattern\""`. */
+    evaluator?: string;
+}
+
+function requiredConfigError(kind: string, key: string, evaluator?: string): Error {
+    const who = evaluator !== undefined ? `${evaluator} evaluator` : 'evaluator';
+    return new Error(`${who} requires ${kind} config "${key}"`);
+}
+
+/**
+ * Read a string entry from a rule's evaluator config. Returns the value when it is a string,
+ * the `fallback` when one is supplied, otherwise throws — so required keys fail loudly.
+ */
+export function configString(
+    config: Record<string, unknown>,
+    key: string,
+    fallback?: string,
+    options: ConfigAccessorOptions = {},
+): string {
+    const value = config[key];
+    if (typeof value === 'string') return value;
+    if (fallback !== undefined) return fallback;
+    throw requiredConfigError('string', key, options.evaluator);
+}
+
+/**
+ * Read a string-array entry from a rule's evaluator config. A bare string is coerced to a
+ * single-element array. Returns the `fallback` when one is supplied and the value is absent;
+ * otherwise throws — so required keys fail loudly.
+ */
+export function configArray(
+    config: Record<string, unknown>,
+    key: string,
+    fallback?: string[],
+    options: ConfigAccessorOptions = {},
+): string[] {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value as string[];
+    if (typeof value === 'string') return [value];
+    if (fallback !== undefined) return fallback;
+    throw requiredConfigError('string[]', key, options.evaluator);
+}
+
+/** Read a finite-number entry from a rule's evaluator config, falling back when absent or invalid. */
+export function configNumber(config: Record<string, unknown>, key: string, fallback: number): number {
+    const value = config[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+
 /**
  * Split a leading ripgrep/PCRE-style `(?flags)` inline group off a regex source.
  *

package/src/evaluators/forbidden-import-evaluator.ts

@@ -5,7 +5,7 @@ import {
     type RuleEvaluationResult,
     type RuleEvaluator,
 } from '../types';
-import { escapeRegExp, scanFiles, stringArray } from './file-utils';
+import { configArray, escapeRegExp, scanFiles, stringArray } from './file-utils';
 
 /** A forbidden entry: either an exact import specifier or a raw source pattern. */
 type ForbiddenEntry =
@@ -49,7 +49,7 @@ export class ForbiddenImportEvaluator implements RuleEvaluator {
         context: RuleContext,
         config: Record<string, unknown>,
     ): Promise<RuleEvaluationResult> {
-        const forbidden = arrayConfig(config, 'patterns');
+        const forbidden = configArray(config, 'patterns', undefined, { evaluator: 'forbidden-import' });
         const files = await scanFiles({
             workdir: context.workdir,
             include: rule.include ?? ['.ts', '.tsx', '.js', '.jsx'],
@@ -130,10 +130,3 @@ function compileEntry(entry: ForbiddenEntry): ScanEntry {
     }
     return { regex: new RegExp(entry.pattern), label: entry.pattern };
 }
-
-function arrayConfig(config: Record<string, unknown>, key: string): string[] {
-    const value = config[key];
-    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value;
-    if (typeof value === 'string') return [value];
-    throw new Error(`forbidden-import evaluator requires string[] config "${key}"`);
-}

package/src/evaluators/path-evaluator.ts

@@ -1,5 +1,4 @@
-import { resolve } from 'node:path';
-import { NodeFileSystem } from '@gobing-ai/ts-runtime';
+import { joinPath, NodeFileSystem } from '@gobing-ai/ts-runtime';
 import {
     type ConstraintRule,
     createFinding,
@@ -7,7 +6,7 @@ import {
     type RuleEvaluationResult,
     type RuleEvaluator,
 } from '../types';
-import { discoverFiles, matchesGlob } from './file-utils';
+import { configArray, configString, discoverFiles, matchesGlob } from './file-utils';
 
 /**
  * Evaluates file/directory presence constraints.
@@ -82,11 +81,11 @@ export class PathEvaluator implements RuleEvaluator {
         context: RuleContext,
         config: Record<string, unknown>,
     ): Promise<RuleEvaluationResult> {
-        const paths = arrayConfig(config, 'paths');
-        const mode = stringConfig(config, 'mode', 'require');
+        const paths = configArray(config, 'paths', undefined, { evaluator: 'path' });
+        const mode = configString(config, 'mode', 'require');
         const findings = [];
         for (const path of paths) {
-            const exists = await this.fs.exists(resolve(context.workdir, path));
+            const exists = await this.fs.exists(joinPath(context.workdir, path));
             if (mode === 'forbid' && exists) {
                 findings.push(createFinding(rule, `Forbidden path exists: ${path}`, path, { code: 'path:forbidden' }));
             }
@@ -97,15 +96,3 @@ export class PathEvaluator implements RuleEvaluator {
         return { findings, fixes: [] };
     }
 }
-
-function arrayConfig(config: Record<string, unknown>, key: string): string[] {
-    const value = config[key];
-    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value;
-    if (typeof value === 'string') return [value];
-    throw new Error(`path evaluator requires config "${key}" (string[]) or "must" (present|absent)`);
-}
-
-function stringConfig(config: Record<string, unknown>, key: string, fallback: string): string {
-    const value = config[key];
-    return typeof value === 'string' ? value : fallback;
-}

package/src/evaluators/regex-evaluator.ts

@@ -5,7 +5,7 @@ import {
     type RuleEvaluationResult,
     type RuleEvaluator,
 } from '../types';
-import { parseInlineFlags, scanFiles } from './file-utils';
+import { configString, parseInlineFlags, scanFiles } from './file-utils';
 
 /**
  * Evaluates whether source files match or avoid a regex pattern.
@@ -25,11 +25,11 @@ export class RegexEvaluator implements RuleEvaluator {
     async evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult> {
         const config = rule.evaluator.config ?? {};
         const { pattern, flags } = normalizePattern(
-            stringConfig(config, 'pattern'),
-            stringConfig(config, 'flags', ''),
+            configString(config, 'pattern', undefined, { evaluator: 'regex' }),
+            configString(config, 'flags', ''),
             config.multiline === true,
         );
-        const mode = stringConfig(config, 'mode', 'forbid');
+        const mode = configString(config, 'mode', 'forbid');
         const regex = new RegExp(pattern, flags);
         const files = await scanFiles({
             workdir: context.workdir,
@@ -103,13 +103,6 @@ function normalizePattern(
     return { pattern, flags: [...flagSet].join('') };
 }
 
-function stringConfig(config: Record<string, unknown>, key: string, fallback?: string): string {
-    const value = config[key];
-    if (typeof value === 'string') return value;
-    if (fallback !== undefined) return fallback;
-    throw new Error(`regex evaluator requires string config "${key}"`);
-}
-
 /** Return the one-based line containing a string offset. */
 function lineForOffset(content: string, offset: number): number {
     let line = 1;