perf(incidentReplay): cache lowercased evidence text in causal/pattern hot paths

detectCausalChains() previously called evidenceText() and toLowerCase()

twice per (event, causal-pair) — for N events and 8 pairs that's 16N

redundant string allocations. Now we precompute lowerTexts once per

investigate() and the inner loop is a plain indexOf scan.

matchPatterns() also rebuilt allText with += inside the loop and then

re-lowercased the entire corpus on every pattern's keywordMatchScore

call. Switched to array+join + a single allTextLower, with a new

keywordMatchScoreLower() helper used by the hot path. Public

keywordMatchScore() behavior is unchanged.

Add __tests__/incidentReplay.perf.test.js (5 new tests, 62 total in

the file's two suites): mixed-case keyword matching via custom

patterns, no false positives when keywords are absent, causal chain

detection when cause/effect strings only appear inside data values,

rejection of effect-before-cause, and a 200-event scale smoke test.

Verified: node -c on changed files; full jest suite green

(182 files, 6601 tests passed, 46s).

Author: Repo Gardener

__tests__/incidentReplay.perf.test.js

@@ -0,0 +1,178 @@
+'use strict';
+
+/**
+ * Regression tests for incidentReplay perf optimizations and edge cases
+ * around pattern matching + causal chain detection.
+ *
+ * These exercise behaviors the main suite doesn't cover:
+ *  - Mixed-case keyword matching (the optimized hot path lowercases the
+ *    corpus once; keywords themselves are still lowercased per-pair).
+ *  - Custom user-registered patterns (so the optimization doesn't regress
+ *    when customPatterns is non-empty).
+ *  - Causal chains where cause/effect substrings appear inside `data` keys
+ *    or values, not just `source`/`type`.
+ *  - Stability under bigger evidence sets (smoke for the precomputed
+ *    lowerTexts buffer in detectCausalChains).
+ */
+
+var mod = require('../docs/shared/incidentReplay');
+
+describe('Lab Incident Replay - perf regression + edge cases', function () {
+    var engine;
+
+    beforeEach(function () {
+        engine = mod.createIncidentReplay();
+    });
+
+    describe('pattern matching - case insensitivity', function () {
+        it('matches keywords regardless of case in the evidence corpus', function () {
+            // Register a deterministic custom pattern so we control the keywords.
+            engine.registerPattern({
+                name: 'mixed_case_probe',
+                label: 'Mixed Case Probe',
+                signature: {
+                    sources: ['print_log'],
+                    keywords: ['CUSTOM_FAULT', 'StrangeWarning']
+                },
+                recommendations: ['probe-rec']
+            });
+
+            engine.loadEvidence([
+                {
+                    source: 'print_log',
+                    timestamp: '2026-04-28T14:00:00Z',
+                    type: 'note',
+                    description: 'Operator reported strangewarning during run'
+                },
+                {
+                    source: 'print_log',
+                    timestamp: '2026-04-28T14:05:00Z',
+                    type: 'fault',
+                    data: { reason: 'custom_fault triggered' }
+                }
+            ]);
+
+            var report = engine.investigate({ incidentTime: '2026-04-28T14:05:00Z' });
+            var probe = report.patternMatches.find(function (m) {
+                return m.pattern === 'mixed_case_probe';
+            });
+            expect(probe).toBeDefined();
+            // Both keywords present (case-insensitive) -> keywordMatch == 1.0
+            expect(probe.keywordMatch).toBe(1);
+            // Source matches -> sourceOverlap == 1.0
+            expect(probe.sourceOverlap).toBe(1);
+            // Combined similarity = 0.4*1 + 0.6*1 = 1.0 (rounded)
+            expect(probe.similarity).toBe(1);
+        });
+
+        it('produces no false positives when keywords are absent', function () {
+            engine.registerPattern({
+                name: 'absent_pattern',
+                label: 'Absent',
+                signature: {
+                    sources: ['quality'],
+                    keywords: ['this_string_should_never_appear_xyzzy']
+                },
+                recommendations: []
+            });
+
+            engine.loadEvidence([
+                { source: 'quality', timestamp: '2026-04-28T14:00:00Z', type: 'reading', data: { ok: true } }
+            ]);
+
+            var report = engine.investigate({ incidentTime: '2026-04-28T14:00:00Z' });
+            var match = report.patternMatches.find(function (m) {
+                return m.pattern === 'absent_pattern';
+            });
+            // sourceOverlap = 1, kwScore = 0, similarity = 0.4 -> kept (>0.1)
+            // but keywordMatch must be 0.
+            if (match) {
+                expect(match.keywordMatch).toBe(0);
+            }
+        });
+    });
+
+    describe('causal chain detection - data field scans', function () {
+        it('detects clog -> under_extrusion when terms only appear inside data values', function () {
+            engine.loadEvidence([
+                {
+                    source: 'equipment',
+                    timestamp: '2026-04-28T14:00:00Z',
+                    type: 'reading',
+                    data: { note: 'nozzle clog suspected', pressure: 220 }
+                },
+                {
+                    source: 'print_log',
+                    timestamp: '2026-04-28T14:10:00Z',
+                    type: 'alert',
+                    data: { warning: 'under_extrusion observed', flow: 0.1 }
+                }
+            ]);
+
+            var report = engine.investigate({ incidentTime: '2026-04-28T14:10:00Z' });
+            var chain = report.causalChains.find(function (c) {
+                return c.label.indexOf('Nozzle clog') !== -1;
+            });
+            expect(chain).toBeDefined();
+            expect(chain.delayMinutes).toBeCloseTo(10, 1);
+            // Strength decays linearly over 1 hour; 10 min -> ~0.83
+            expect(chain.strength).toBeGreaterThan(0.7);
+            expect(chain.strength).toBeLessThanOrEqual(1);
+        });
+
+        it('orders cause before effect (no chain when effect precedes cause)', function () {
+            engine.loadEvidence([
+                {
+                    source: 'quality',
+                    timestamp: '2026-04-28T14:00:00Z',
+                    type: 'excursion',
+                    data: { viability: 60 }
+                },
+                {
+                    source: 'environmental',
+                    timestamp: '2026-04-28T14:30:00Z',
+                    type: 'reading',
+                    data: { temperature: 42 }
+                }
+            ]);
+
+            var report = engine.investigate({ incidentTime: '2026-04-28T14:30:00Z' });
+            var bogus = report.causalChains.find(function (c) {
+                return c.label.indexOf('Temperature') !== -1;
+            });
+            expect(bogus).toBeUndefined();
+        });
+    });
+
+    describe('scale - many events through optimized hot paths', function () {
+        it('investigates 200 events without throwing and returns a coherent report', function () {
+            var evidence = [];
+            var base = Date.parse('2026-04-28T14:00:00Z');
+            for (var i = 0; i < 200; i++) {
+                evidence.push({
+                    source: i % 2 === 0 ? 'environmental' : 'quality',
+                    timestamp: new Date(base + i * 30000).toISOString(),
+                    type: i % 5 === 0 ? 'excursion' : 'reading',
+                    data: i % 3 === 0
+                        ? { temperature: 30 + (i % 20), note: 'temperature drift detected' }
+                        : { viability: 70 + (i % 25) }
+                });
+            }
+            engine.loadEvidence(evidence);
+
+            var report = engine.investigate({
+                incidentTime: new Date(base + 200 * 30000).toISOString()
+            });
+
+            expect(report).toBeDefined();
+            expect(Array.isArray(report.causalChains)).toBe(true);
+            expect(Array.isArray(report.patternMatches)).toBe(true);
+            // We seeded clear temperature->viability signal, so at least one chain
+            // for that pair must be found.
+            var tempChain = report.causalChains.find(function (c) {
+                return c.label.indexOf('Temperature') !== -1;
+            });
+            expect(tempChain).toBeDefined();
+        });
+    });
+});

docs/shared/incidentReplay.js

@@ -193,7 +193,13 @@ function computeStats(values) {
 
 function keywordMatchScore(text, keywords) {
     if (!text || !keywords || keywords.length === 0) return 0;
-    var lower = text.toLowerCase();
+    return keywordMatchScoreLower(text.toLowerCase(), keywords);
+}
+
+// Variant that assumes `lower` is already lowercased. Used by the pattern
+// matcher hot path so the corpus is not re-lowercased per pattern.
+function keywordMatchScoreLower(lower, keywords) {
+    if (!lower || !keywords || keywords.length === 0) return 0;
     var hits = 0;
     for (var i = 0; i < keywords.length; i++) {
         if (lower.indexOf(keywords[i].toLowerCase()) !== -1) hits++;
@@ -387,15 +393,24 @@ function createIncidentReplay() {
             { cause: 'clog', effect: 'under_extrusion', label: 'Nozzle clog → Under-extrusion' }
         ];
 
+        // PERF: Precompute lowercased evidenceText once per event so each
+        // (event, pair) check is a single substring scan instead of rebuilding
+        // the evidenceText string and re-lowercasing it twice. For N events
+        // and 8 causal pairs this drops ~16N redundant string allocations.
+        var lowerTexts = new Array(sorted.length);
+        for (var li = 0; li < sorted.length; li++) {
+            lowerTexts[li] = evidenceText(sorted[li]).toLowerCase();
+        }
+
         for (var p = 0; p < causalPairs.length; p++) {
             var pair = causalPairs[p];
             var causeEvents = [];
             var effectEvents = [];
 
             for (var i = 0; i < sorted.length; i++) {
-                var text = evidenceText(sorted[i]);
-                if (text.toLowerCase().indexOf(pair.cause) !== -1) causeEvents.push(sorted[i]);
-                if (text.toLowerCase().indexOf(pair.effect) !== -1) effectEvents.push(sorted[i]);
+                var text = lowerTexts[i];
+                if (text.indexOf(pair.cause) !== -1) causeEvents.push(sorted[i]);
+                if (text.indexOf(pair.effect) !== -1) effectEvents.push(sorted[i]);
             }
 
             for (var c = 0; c < causeEvents.length; c++) {
@@ -426,12 +441,17 @@ function createIncidentReplay() {
         var allPatterns = BUILT_IN_PATTERNS.concat(customPatterns);
         if (allPatterns.length === 0 || sorted.length === 0) return [];
 
+        // PERF: Build evidenceSources + concatenated text in a single pass
+        // using an array+join (avoids quadratic-ish string growth) and
+        // pre-lowercase once so keywordMatchScore doesn't re-lowercase the
+        // entire corpus on every pattern iteration.
         var evidenceSources = {};
-        var allText = '';
+        var textParts = new Array(sorted.length);
         for (var i = 0; i < sorted.length; i++) {
             evidenceSources[sorted[i].source] = true;
-            allText += ' ' + evidenceText(sorted[i]);
+            textParts[i] = evidenceText(sorted[i]);
         }
+        var allTextLower = textParts.join(' ').toLowerCase();
 
         var matches = [];
         for (var p = 0; p < allPatterns.length; p++) {
@@ -447,8 +467,8 @@ function createIncidentReplay() {
             }
             var sourceScore = sig.sources && sig.sources.length > 0 ? sourceHits / sig.sources.length : 0;
 
-            // Keyword match score
-            var kwScore = sig.keywords ? keywordMatchScore(allText, sig.keywords) : 0;
+            // Keyword match score (allTextLower already lowercased)
+            var kwScore = sig.keywords ? keywordMatchScoreLower(allTextLower, sig.keywords) : 0;
 
             // Combined similarity
             var similarity = round((sourceScore * 0.4 + kwScore * 0.6), 2);