@mmnto/totem 1.15.2 → 1.15.4

package/dist/regex-safety/apply-rules-bounded.test.js

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'vitest';
+import { makeRuleEngineCtx } from '../test-utils.js';
+import { applyRulesToAdditionsBounded } from './apply-rules-bounded.js';
+import { RegexEvaluator } from './evaluator.js';
+function addition(file, line, lineNumber) {
+    return { file, line, lineNumber, precedingLine: null };
+}
+function regexRule(lessonHash, pattern, engine = 'regex') {
+    return {
+        lessonHash,
+        lessonHeading: `rule ${lessonHash}`,
+        pattern,
+        message: `violation for ${lessonHash}`,
+        engine,
+        compiledAt: '2026-04-23T00:00:00Z',
+    };
+}
+describe('applyRulesToAdditionsBounded — happy path', () => {
+    it('flags matching additions under a sync evaluator', async () => {
+        const evaluator = new RegexEvaluator();
+        try {
+            const rules = [regexRule('h1', 'console\\.log')];
+            const additions = [
+                addition('foo.ts', 'console.log("a")', 10),
+                addition('foo.ts', 'logger.info("b")', 11),
+            ];
+            const result = await applyRulesToAdditionsBounded(makeRuleEngineCtx(), rules, additions, {
+                evaluator,
+                timeoutMode: 'strict',
+                repoRoot: '/tmp/repo',
+            });
+            expect(result.violations).toHaveLength(1);
+            expect(result.violations[0]?.rule.lessonHash).toBe('h1');
+            expect(result.violations[0]?.lineNumber).toBe(10);
+            expect(result.timeoutOutcomes).toEqual([]);
+        }
+        finally {
+            await evaluator.dispose();
+        }
+    });
+    it('respects fileGlobs when evaluating additions', async () => {
+        const evaluator = new RegexEvaluator();
+        try {
+            const rule = {
+                ...regexRule('scoped', 'foo'),
+                fileGlobs: ['**/*.md'],
+            };
+            const additions = [
+                addition('readme.md', 'foo', 1),
+                addition('app.ts', 'foo', 1),
+            ];
+            const result = await applyRulesToAdditionsBounded(makeRuleEngineCtx(), [rule], additions, {
+                evaluator,
+                timeoutMode: 'strict',
+                repoRoot: '/tmp/repo',
+            });
+            expect(result.violations).toHaveLength(1);
+            expect(result.violations[0]?.file).toBe('readme.md');
+        }
+        finally {
+            await evaluator.dispose();
+        }
+    });
+});
+describe('applyRulesToAdditionsBounded — timeout strict', () => {
+    it('returns a RuleTimeoutOutcome and excludes violations for the timing-out rule', async () => {
+        const evaluator = new RegexEvaluator({ timeoutMs: 150, softWarningMs: 50 });
+        try {
+            const rules = [regexRule('redos', '(a+)+b'), regexRule('healthy', 'foo')];
+            const additions = [
+                addition('a.ts', 'a'.repeat(50000) + 'c', 1),
+                addition('b.ts', 'foo', 2),
+            ];
+            const result = await applyRulesToAdditionsBounded(makeRuleEngineCtx(), rules, additions, {
+                evaluator,
+                timeoutMode: 'strict',
+                repoRoot: '/tmp/repo',
+            });
+            const timeoutHashes = result.timeoutOutcomes.map((o) => o.ruleHash);
+            expect(timeoutHashes).toContain('redos');
+            // Healthy rule should still produce its violation.
+            const healthyViolation = result.violations.find((v) => v.rule.lessonHash === 'healthy');
+            expect(healthyViolation).toBeDefined();
+        }
+        finally {
+            await evaluator.dispose();
+        }
+    });
+});
+describe('applyRulesToAdditionsBounded — timeout lenient', () => {
+    it('records timeout outcomes but does not differ from strict at the engine layer', async () => {
+        // The strict/lenient semantics are enforced at the CLI layer based on
+        // the timeoutOutcomes array this function returns. The engine itself
+        // is policy-free — it records the outcome and lets the caller decide
+        // the exit-code effect. Locking this in prevents future drift where
+        // the engine starts making policy decisions instead of surfacing them.
+        const evaluator = new RegexEvaluator({ timeoutMs: 150, softWarningMs: 50 });
+        try {
+            const rules = [regexRule('redos', '(a+)+b')];
+            const additions = [addition('a.ts', 'a'.repeat(50000) + 'c', 1)];
+            const strict = await applyRulesToAdditionsBounded(makeRuleEngineCtx(), rules, additions, {
+                evaluator,
+                timeoutMode: 'strict',
+                repoRoot: '/tmp/repo',
+            });
+            const lenient = await applyRulesToAdditionsBounded(makeRuleEngineCtx(), rules, additions, {
+                evaluator,
+                timeoutMode: 'lenient',
+                repoRoot: '/tmp/repo',
+            });
+            expect(strict.timeoutOutcomes).toHaveLength(1);
+            expect(lenient.timeoutOutcomes).toHaveLength(1);
+        }
+        finally {
+            await evaluator.dispose();
+        }
+    });
+});
+describe('applyRulesToAdditionsBounded — invalid pattern', () => {
+    it('fails loud on a compiled rule with an invalid regex (matches existing rule-engine contract)', async () => {
+        const evaluator = new RegexEvaluator();
+        try {
+            const rules = [regexRule('broken', '(unclosed')];
+            const additions = [addition('a.ts', 'foo', 1)];
+            await expect(applyRulesToAdditionsBounded(makeRuleEngineCtx(), rules, additions, {
+                evaluator,
+                timeoutMode: 'strict',
+                repoRoot: '/tmp/repo',
+            })).rejects.toThrow(/invalid regex|cannot be evaluated/i);
+        }
+        finally {
+            await evaluator.dispose();
+        }
+    });
+});
+//# sourceMappingURL=apply-rules-bounded.test.js.map

package/dist/regex-safety/apply-rules-bounded.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-rules-bounded.test.js","sourceRoot":"","sources":["../../src/regex-safety/apply-rules-bounded.test.ts"],"names":[],"mappings":"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"}

package/dist/regex-safety/evaluator.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Persistent-worker regex evaluator with per-batch timeout (mmnto-ai/totem#1641).
+ *
+ * Spawns one Node worker thread on construction, serializes batches onto
+ * it, and enforces a main-thread timeout. If a pattern catastrophic-
+ * backtracks inside the worker, the main-thread timer fires, calls
+ * `worker.terminate()`, and respawns a fresh worker for the next batch.
+ * Every evaluation resolves with one of three outcomes — `ok` (matched
+ * indices + elapsed + softWarning flag), `timeout` (the worker was
+ * terminated), or `error` (the pattern was syntactically invalid; the
+ * worker is still alive). The caller decides strict vs lenient handling.
+ *
+ * Invariants:
+ * - At most one `Worker` alive per evaluator instance.
+ * - `pending` never holds stale entries past a batch's terminal state.
+ * - Batches are serialized (one in-flight at a time) — no multiplexing.
+ * - Telemetry is emitted on every terminal outcome via the
+ *   `onTelemetry` callback the caller supplies; if absent, telemetry
+ *   is silently dropped (safe — the evaluator itself never fails on
+ *   telemetry-sink failure).
+ */
+import type { RegexTelemetry } from './telemetry.js';
+export interface RegexEvaluatorConfig {
+    /** Hard timeout per batch (ms). Exceeded batches terminate the worker. */
+    timeoutMs: number;
+    /** Soft-warning threshold (ms). Sub-timeout but slow; sets the flag on telemetry. */
+    softWarningMs: number;
+}
+export interface EvaluateInput {
+    ruleHash: string;
+    pattern: string;
+    flags: string;
+    lines: readonly string[];
+}
+export type EvaluateResult = {
+    kind: 'ok';
+    matchedIndices: number[];
+    elapsedMs: number;
+    softWarningTriggered: boolean;
+} | {
+    kind: 'timeout';
+    elapsedMs: number;
+} | {
+    kind: 'error';
+    message: string;
+    elapsedMs: number;
+};
+export declare class RegexEvaluator {
+    private worker;
+    private readonly pending;
+    private readonly config;
+    private readonly onTelemetry;
+    private queue;
+    private disposed;
+    /**
+     * Coalesces concurrent respawn requests (mmnto-ai/totem#1641 Shield review
+     * round-1). Without this, a timeout event firing at roughly the same
+     * moment as a worker `error` event can call `spawnWorker()` twice,
+     * leaking a thread. `evaluate()` also awaits this promise before
+     * `postMessage` so a batch scheduled during a respawn waits for the
+     * new worker instead of silently dropping against a null handle.
+     */
+    private respawnPromise;
+    /**
+     * Worker-online gate (mmnto-ai/totem#1641, CI round-1 fix). The Node
+     * `Worker` constructor returns before the thread is actually running
+     * (thread-spawn takes ~30-50ms). If `evaluate()` starts its timeout
+     * timer before the worker is online, a slow CI box can trip a
+     * spurious timeout on the first batch. Gate postMessage on this
+     * promise so cold-start cost never counts against the budget.
+     */
+    private workerReady;
+    /**
+     * Consecutive-respawn counter (Shield review round-1). If the worker
+     * keeps dying at spawn time (missing worker.js, syntax error in the
+     * worker script, etc.), unbounded respawn becomes a CPU-pegging loop.
+     * The counter increments on each respawn, resets on every successful
+     * evaluation, and flips `permanentlyFailed` once the budget is spent.
+     */
+    private consecutiveRespawns;
+    private permanentlyFailed;
+    private static readonly MAX_CONSECUTIVE_RESPAWNS;
+    constructor(config?: Partial<RegexEvaluatorConfig>, onTelemetry?: (record: RegexTelemetry) => void);
+    evaluate(input: EvaluateInput & {
+        redactedPath?: string;
+    }): Promise<EvaluateResult>;
+    dispose(): Promise<void>;
+    private evaluateOnce;
+    private spawnWorker;
+    private respawnWorker;
+    private handleMessage;
+    private rejectAllPendingAsCrash;
+    private emitTelemetry;
+}
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/regex-safety/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/regex-safety/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AASH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,OAAO,CAAA;CAAE,GAC1F;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAkC1D,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiD;IAC7E,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,QAAQ,CAAS;IACzB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc,CAA8B;IACpD;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW,CAAoC;IACvD;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAK;gBAGnD,MAAM,GAAE,OAAO,CAAC,oBAAoB,CAAM,EAC1C,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI;IAO1C,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IA6CnF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAa9B,OAAO,CAAC,YAAY;IAgDpB,OAAO,CAAC,WAAW;YAsCL,aAAa;IAkC3B,OAAO,CAAC,aAAa;IAkCrB,OAAO,CAAC,uBAAuB;IAiB/B,OAAO,CAAC,aAAa;CAQtB"}

package/dist/regex-safety/evaluator.js

@@ -0,0 +1,314 @@
+/**
+ * Persistent-worker regex evaluator with per-batch timeout (mmnto-ai/totem#1641).
+ *
+ * Spawns one Node worker thread on construction, serializes batches onto
+ * it, and enforces a main-thread timeout. If a pattern catastrophic-
+ * backtracks inside the worker, the main-thread timer fires, calls
+ * `worker.terminate()`, and respawns a fresh worker for the next batch.
+ * Every evaluation resolves with one of three outcomes — `ok` (matched
+ * indices + elapsed + softWarning flag), `timeout` (the worker was
+ * terminated), or `error` (the pattern was syntactically invalid; the
+ * worker is still alive). The caller decides strict vs lenient handling.
+ *
+ * Invariants:
+ * - At most one `Worker` alive per evaluator instance.
+ * - `pending` never holds stale entries past a batch's terminal state.
+ * - Batches are serialized (one in-flight at a time) — no multiplexing.
+ * - Telemetry is emitted on every terminal outcome via the
+ *   `onTelemetry` callback the caller supplies; if absent, telemetry
+ *   is silently dropped (safe — the evaluator itself never fails on
+ *   telemetry-sink failure).
+ */
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { TotemError } from '../errors.js';
+const DEFAULT_CONFIG = {
+    timeoutMs: 100,
+    softWarningMs: 50,
+};
+function resolveWorkerPath() {
+    // In the built bundle, this module compiles to dist/regex-safety/evaluator.js
+    // sitting next to dist/regex-safety/worker.js — the relative lookup
+    // resolves directly. In vitest/dev the current module is the .ts source
+    // file under src/regex-safety/ with no sibling worker.js; fall back to
+    // the built dist path so tests can exercise the real worker without
+    // requiring a loader shim.
+    const here = fileURLToPath(import.meta.url);
+    const dir = path.dirname(here);
+    const siblingJs = path.join(dir, 'worker.js');
+    if (fs.existsSync(siblingJs))
+        return siblingJs;
+    const distFallback = path.resolve(dir, '..', '..', 'dist', 'regex-safety', 'worker.js');
+    if (fs.existsSync(distFallback))
+        return distFallback;
+    // Last resort: return the expected sibling path. Worker() will throw
+    // a descriptive MODULE_NOT_FOUND the caller can surface.
+    return siblingJs;
+}
+export class RegexEvaluator {
+    worker = null;
+    pending = new Map();
+    config;
+    onTelemetry;
+    queue = Promise.resolve();
+    disposed = false;
+    /**
+     * Coalesces concurrent respawn requests (mmnto-ai/totem#1641 Shield review
+     * round-1). Without this, a timeout event firing at roughly the same
+     * moment as a worker `error` event can call `spawnWorker()` twice,
+     * leaking a thread. `evaluate()` also awaits this promise before
+     * `postMessage` so a batch scheduled during a respawn waits for the
+     * new worker instead of silently dropping against a null handle.
+     */
+    respawnPromise = null;
+    /**
+     * Worker-online gate (mmnto-ai/totem#1641, CI round-1 fix). The Node
+     * `Worker` constructor returns before the thread is actually running
+     * (thread-spawn takes ~30-50ms). If `evaluate()` starts its timeout
+     * timer before the worker is online, a slow CI box can trip a
+     * spurious timeout on the first batch. Gate postMessage on this
+     * promise so cold-start cost never counts against the budget.
+     */
+    workerReady = Promise.resolve();
+    /**
+     * Consecutive-respawn counter (Shield review round-1). If the worker
+     * keeps dying at spawn time (missing worker.js, syntax error in the
+     * worker script, etc.), unbounded respawn becomes a CPU-pegging loop.
+     * The counter increments on each respawn, resets on every successful
+     * evaluation, and flips `permanentlyFailed` once the budget is spent.
+     */
+    consecutiveRespawns = 0;
+    permanentlyFailed = false;
+    static MAX_CONSECUTIVE_RESPAWNS = 3;
+    constructor(config = {}, onTelemetry) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.onTelemetry = onTelemetry;
+        this.spawnWorker();
+    }
+    async evaluate(input) {
+        if (this.disposed) {
+            throw new TotemError('CHECK_FAILED', 'RegexEvaluator has been disposed', 'Construct a new RegexEvaluator before calling evaluate(). The dispose() method releases the worker and marks the instance unusable (mmnto-ai/totem#1641).');
+        }
+        if (this.permanentlyFailed) {
+            throw new TotemError('CHECK_FAILED', `RegexEvaluator exhausted ${RegexEvaluator.MAX_CONSECUTIVE_RESPAWNS} consecutive respawn attempts without a successful evaluation`, 'The regex worker script likely failed to initialize (missing worker.js, syntax error in the worker module, or a Node version that cannot load it). Inspect the worker script at packages/core/src/regex-safety/worker.ts and rebuild @mmnto/totem.');
+        }
+        // Serialize: the next batch waits for the current one to finish.
+        // Single-worker invariant — no batch multiplexing.
+        const previous = this.queue;
+        let release;
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        this.queue = previous.then(() => gate);
+        await previous;
+        // Wait for any in-flight respawn so postMessage does not race a
+        // null `this.worker` handle (Shield review round-1 race fix).
+        if (this.respawnPromise) {
+            await this.respawnPromise;
+        }
+        // Wait for the worker thread to finish spawning before posting.
+        // Cold-start (thread spawn + module load) is ~30-50ms and must not
+        // count against the batch timeout budget, otherwise a slow CI box
+        // trips a spurious timeout on the first batch (CI round-1 fix).
+        await this.workerReady;
+        try {
+            return await this.evaluateOnce(input);
+        }
+        finally {
+            release();
+        }
+    }
+    async dispose() {
+        this.disposed = true;
+        await this.queue;
+        if (this.worker) {
+            await this.worker.terminate();
+            this.worker = null;
+        }
+        for (const entry of this.pending.values()) {
+            clearTimeout(entry.timer);
+        }
+        this.pending.clear();
+    }
+    evaluateOnce(input) {
+        return new Promise((resolve) => {
+            const id = crypto.randomBytes(8).toString('hex');
+            const startedAt = Date.now();
+            const inputSize = input.lines.reduce((acc, line) => acc + line.length, 0);
+            const timer = setTimeout(() => {
+                const entry = this.pending.get(id);
+                if (!entry)
+                    return;
+                this.pending.delete(id);
+                const elapsedMs = Date.now() - startedAt;
+                this.emitTelemetry({
+                    ruleHash: entry.ruleHash,
+                    redactedPath: entry.redactedPath,
+                    matchedInputSize: entry.inputSize,
+                    elapsedTimeMs: elapsedMs,
+                    timeoutTriggered: true,
+                    softWarningTriggered: false,
+                });
+                // Terminate worker — the regex is hung on a line we can't interrupt.
+                // Await respawn before resolving so the next queued evaluate() does
+                // not race a not-yet-spawned worker and get a second timeout.
+                void this.respawnWorker().finally(() => {
+                    entry.resolve({ kind: 'timeout', elapsedMs });
+                });
+            }, this.config.timeoutMs);
+            this.pending.set(id, {
+                resolve,
+                timer,
+                ruleHash: input.ruleHash,
+                startedAt,
+                inputSize,
+                redactedPath: input.redactedPath ?? '<unknown>',
+            });
+            const request = {
+                id,
+                pattern: input.pattern,
+                flags: input.flags,
+                lines: input.lines,
+            };
+            this.worker?.postMessage(request);
+        });
+    }
+    spawnWorker() {
+        const worker = new Worker(resolveWorkerPath());
+        this.worker = worker;
+        this.workerReady = new Promise((resolve) => {
+            worker.once('online', () => resolve());
+        });
+        worker.on('message', (response) => this.handleMessage(response));
+        worker.on('error', () => {
+            // Worker crashed outside of a normal message flow (e.g., an
+            // internal error). The queued-evaluate lock only releases when
+            // the in-flight promise resolves, so we must await respawn before
+            // resolving pending entries — otherwise the next evaluate() races
+            // a null `this.worker` and postMessage silently drops (spurious
+            // timeout on the next batch). Same invariant the timeout path
+            // already relies on (see evaluateOnce timer callback above).
+            void this.respawnWorker().finally(() => {
+                this.rejectAllPendingAsCrash();
+            });
+        });
+        worker.on('exit', (code) => {
+            // GCA PR #1644 round-1 — handle unexpected worker exits (OOM kill,
+            // internal Node crash) that do not surface through the `error`
+            // event. Skip respawn on graceful exit (code 0) and on explicit
+            // dispose (terminate() drives exit with non-zero, but we only
+            // spin up the respawn after checking the flag). Skip if this
+            // handle is no longer the active worker — `respawnWorker` calls
+            // `terminate()` on the prior worker before setting a new one, and
+            // the exit event for the old handle fires after the field has
+            // moved on; respawning again would leak a thread.
+            if (this.disposed)
+                return;
+            if (code === 0)
+                return;
+            if (this.worker !== worker)
+                return;
+            void this.respawnWorker().finally(() => {
+                this.rejectAllPendingAsCrash();
+            });
+        });
+    }
+    async respawnWorker() {
+        // Coalesce concurrent respawn calls (Shield review round-1). If two
+        // events (timeout + error) both request a respawn, they share the
+        // same in-flight promise instead of spawning two workers.
+        if (this.respawnPromise)
+            return this.respawnPromise;
+        if (this.disposed)
+            return;
+        this.respawnPromise = (async () => {
+            try {
+                this.consecutiveRespawns += 1;
+                if (this.consecutiveRespawns > RegexEvaluator.MAX_CONSECUTIVE_RESPAWNS) {
+                    this.permanentlyFailed = true;
+                    this.rejectAllPendingAsCrash();
+                    return;
+                }
+                const old = this.worker;
+                this.worker = null;
+                if (old) {
+                    try {
+                        await old.terminate(); // totem-context: intentional best-effort cleanup — terminate() on an already-dead or still-initializing worker can throw, no recovery path at this layer; the new worker spawn is the load-bearing step.
+                    }
+                    catch {
+                        // No-op (see totem-context on the terminate() call above).
+                    }
+                }
+                if (this.disposed)
+                    return;
+                this.spawnWorker();
+            }
+            finally {
+                this.respawnPromise = null;
+            }
+        })();
+        return this.respawnPromise;
+    }
+    handleMessage(response) {
+        const entry = this.pending.get(response.id);
+        if (!entry)
+            return;
+        this.pending.delete(response.id);
+        clearTimeout(entry.timer);
+        // Any successful round-trip resets the respawn-failure counter.
+        // Persistent spawn failures only matter when they fire back-to-back
+        // with no intervening successful evaluation (Shield review round-1).
+        this.consecutiveRespawns = 0;
+        const elapsedMs = Date.now() - entry.startedAt;
+        const softWarningTriggered = elapsedMs >= this.config.softWarningMs;
+        this.emitTelemetry({
+            ruleHash: entry.ruleHash,
+            redactedPath: entry.redactedPath,
+            matchedInputSize: entry.inputSize,
+            elapsedTimeMs: elapsedMs,
+            timeoutTriggered: false,
+            softWarningTriggered: response.kind === 'ok' ? softWarningTriggered : false,
+        });
+        if (response.kind === 'ok') {
+            entry.resolve({
+                kind: 'ok',
+                matchedIndices: response.matchedIndices,
+                elapsedMs,
+                softWarningTriggered,
+            });
+        }
+        else {
+            entry.resolve({ kind: 'error', message: response.message, elapsedMs });
+        }
+    }
+    rejectAllPendingAsCrash() {
+        for (const [id, entry] of this.pending.entries()) {
+            clearTimeout(entry.timer);
+            const elapsedMs = Date.now() - entry.startedAt;
+            this.emitTelemetry({
+                ruleHash: entry.ruleHash,
+                redactedPath: entry.redactedPath,
+                matchedInputSize: entry.inputSize,
+                elapsedTimeMs: elapsedMs,
+                timeoutTriggered: true,
+                softWarningTriggered: false,
+            });
+            entry.resolve({ kind: 'timeout', elapsedMs });
+            this.pending.delete(id);
+        }
+    }
+    emitTelemetry(record) {
+        if (!this.onTelemetry)
+            return;
+        try {
+            this.onTelemetry(record); // totem-context: intentional best-effort telemetry — the evaluator's correctness contract is regex matches, not telemetry delivery; sink failures (bad callback, disk full, permission error) must not interfere with match results.
+        }
+        catch {
+            // No-op (see totem-context on the onTelemetry call above).
+        }
+    }
+}
+//# sourceMappingURL=evaluator.js.map

package/dist/regex-safety/evaluator.js.map

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

package/dist/regex-safety/evaluator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evaluator.test.d.ts.map

package/dist/regex-safety/evaluator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.test.d.ts","sourceRoot":"","sources":["../../src/regex-safety/evaluator.test.ts"],"names":[],"mappings":""}