agentic-qe 3.10.2 → 3.10.4

package/dist/mcp/tools/qx-analysis/heuristics-engine.js

@@ -51,140 +51,150 @@ export class QXHeuristicsEngine {
                 }
                 break;
             case QXHeuristic.INTUITIVE_DESIGN:
-                const hasNav = context.domMetrics?.semanticStructure?.hasNav;
-                const focusable = context.accessibility?.focusableElementsCount || 0;
-                if (hasNav && focusable > 10) {
-                    score = 82;
-                    findings.push('Intuitive navigation and interaction design');
+                {
+                    const hasNav = context.domMetrics?.semanticStructure?.hasNav;
+                    const focusable = context.accessibility?.focusableElementsCount || 0;
+                    if (hasNav && focusable > 10) {
+                        score = 82;
+                        findings.push('Intuitive navigation and interaction design');
+                    }
+                    else {
+                        score = 55;
+                        issues.push({ description: 'Navigation or interaction patterns unclear', severity: 'medium' });
+                    }
+                    break;
                 }
-                else {
-                    score = 55;
-                    issues.push({ description: 'Navigation or interaction patterns unclear', severity: 'medium' });
-                }
-                break;
             case QXHeuristic.EXACTNESS_AND_CLARITY:
-                score = 70;
-                const hasSemanticStructure = context.domMetrics?.semanticStructure;
-                const structureScore = [
-                    hasSemanticStructure?.hasHeader,
-                    hasSemanticStructure?.hasMain,
-                    hasSemanticStructure?.hasNav,
-                    hasSemanticStructure?.hasFooter,
-                ].filter(Boolean).length;
-                score = 50 + structureScore * 10;
-                if (structureScore >= 3) {
-                    findings.push('Strong visual hierarchy with semantic HTML elements');
-                }
-                else if (structureScore >= 2) {
-                    findings.push('Moderate visual hierarchy - some semantic elements present');
-                    recommendations.push('Add more semantic HTML5 elements for clarity');
-                }
-                else {
-                    issues.push({ description: 'Weak visual hierarchy - missing semantic structure', severity: 'high' });
-                    recommendations.push('Implement semantic HTML5: header, nav, main, footer');
+                {
+                    score = 70;
+                    const hasSemanticStructure = context.domMetrics?.semanticStructure;
+                    const structureScore = [
+                        hasSemanticStructure?.hasHeader,
+                        hasSemanticStructure?.hasMain,
+                        hasSemanticStructure?.hasNav,
+                        hasSemanticStructure?.hasFooter,
+                    ].filter(Boolean).length;
+                    score = 50 + structureScore * 10;
+                    if (structureScore >= 3) {
+                        findings.push('Strong visual hierarchy with semantic HTML elements');
+                    }
+                    else if (structureScore >= 2) {
+                        findings.push('Moderate visual hierarchy - some semantic elements present');
+                        recommendations.push('Add more semantic HTML5 elements for clarity');
+                    }
+                    else {
+                        issues.push({ description: 'Weak visual hierarchy - missing semantic structure', severity: 'high' });
+                        recommendations.push('Implement semantic HTML5: header, nav, main, footer');
+                    }
+                    if (context.metadata?.description && context.metadata.description.length > 20) {
+                        score += 10;
+                        findings.push('Page has descriptive metadata');
+                    }
+                    break;
                 }
-                if (context.metadata?.description && context.metadata.description.length > 20) {
-                    score += 10;
-                    findings.push('Page has descriptive metadata');
-                }
-                break;
             case QXHeuristic.COUNTER_INTUITIVE_DESIGN:
-                score = 85; // High score means few counter-intuitive elements (good)
-                const confusingNav = !context.domMetrics?.semanticStructure?.hasNav && (context.domMetrics?.interactiveElements || 0) > 10;
-                const poorStructure = !context.domMetrics?.semanticStructure?.hasHeader && !context.domMetrics?.semanticStructure?.hasFooter;
-                if (confusingNav) {
-                    score = 45;
-                    issues.push({ description: 'Navigation structure may be counter-intuitive', severity: 'high' });
-                    recommendations.push('Add semantic navigation elements');
-                }
-                if (poorStructure) {
-                    score -= 15;
-                    issues.push({ description: 'Page structure lacks expected header/footer', severity: 'medium' });
+                {
+                    score = 85; // High score means few counter-intuitive elements (good)
+                    const confusingNav = !context.domMetrics?.semanticStructure?.hasNav && (context.domMetrics?.interactiveElements || 0) > 10;
+                    const poorStructure = !context.domMetrics?.semanticStructure?.hasHeader && !context.domMetrics?.semanticStructure?.hasFooter;
+                    if (confusingNav) {
+                        score = 45;
+                        issues.push({ description: 'Navigation structure may be counter-intuitive', severity: 'high' });
+                        recommendations.push('Add semantic navigation elements');
+                    }
+                    if (poorStructure) {
+                        score -= 15;
+                        issues.push({ description: 'Page structure lacks expected header/footer', severity: 'medium' });
+                    }
+                    if (score > 75) {
+                        findings.push('No counter-intuitive design patterns detected');
+                    }
+                    break;
                 }
-                if (score > 75) {
-                    findings.push('No counter-intuitive design patterns detected');
-                }
-                break;
             // ========== Impact Analysis Heuristics (H5.x) ==========
             case QXHeuristic.USER_FEELINGS_IMPACT:
-                const altCoverage = context.accessibility?.altTextsCoverage || 0;
-                const loadTime = context.performance?.loadTime || 0;
-                const ariaLabels = context.accessibility?.ariaLabelsCount || 0;
-                const focusableElements = context.accessibility?.focusableElementsCount || 0;
-                score = 60;
-                // Accessibility impact on feelings (35% weight)
-                if (altCoverage >= 90) {
-                    score += 20;
-                    findings.push('Excellent accessibility (90%+ alt coverage) creates inclusive, positive experience');
-                }
-                else if (altCoverage >= 70) {
-                    score += 12;
-                    findings.push('Good accessibility creates generally positive user feelings');
-                }
-                else if (altCoverage < 50) {
-                    score -= 15;
-                    issues.push({
-                        description: 'Poor accessibility (<50% alt coverage) frustrates users with disabilities',
-                        severity: 'high',
-                    });
-                    recommendations.push('Improve alt text coverage to at least 80% for better accessibility');
-                }
-                // ARIA support impact
-                if (ariaLabels > 5) {
-                    score += 8;
-                    findings.push('Strong ARIA labeling enhances screen reader experience');
-                }
-                // Performance impact on feelings (35% weight)
-                if (loadTime < 1500) {
-                    score += 15;
-                    findings.push('Very fast load time (<1.5s) delights users');
-                }
-                else if (loadTime < 2500) {
-                    score += 8;
-                    findings.push('Fast load time enhances user satisfaction');
-                }
-                else if (loadTime > 4000) {
-                    score -= 20;
-                    issues.push({ description: 'Very slow load time (>4s) causes significant frustration', severity: 'critical' });
-                    recommendations.push('Optimize page load time - target under 2.5 seconds');
-                }
-                else if (loadTime > 3000) {
-                    score -= 12;
-                    issues.push({ description: 'Slow load time causes user frustration', severity: 'high' });
-                }
-                // Error visibility impact
-                if (context.errorIndicators?.hasErrorMessages) {
-                    score -= 12;
-                    issues.push({ description: 'Visible errors reduce user confidence and satisfaction', severity: 'high' });
-                    recommendations.push('Review and fix visible error messages');
-                }
-                // Interaction capability
-                if (focusableElements > 20) {
-                    score += 5;
-                    findings.push('Rich interactive elements provide user control and engagement');
-                }
-                else if (focusableElements < 5) {
-                    score -= 8;
-                    issues.push({ description: 'Limited interactivity may feel restrictive', severity: 'medium' });
+                {
+                    const altCoverage = context.accessibility?.altTextsCoverage || 0;
+                    const loadTime = context.performance?.loadTime || 0;
+                    const ariaLabels = context.accessibility?.ariaLabelsCount || 0;
+                    const focusableElements = context.accessibility?.focusableElementsCount || 0;
+                    score = 60;
+                    // Accessibility impact on feelings (35% weight)
+                    if (altCoverage >= 90) {
+                        score += 20;
+                        findings.push('Excellent accessibility (90%+ alt coverage) creates inclusive, positive experience');
+                    }
+                    else if (altCoverage >= 70) {
+                        score += 12;
+                        findings.push('Good accessibility creates generally positive user feelings');
+                    }
+                    else if (altCoverage < 50) {
+                        score -= 15;
+                        issues.push({
+                            description: 'Poor accessibility (<50% alt coverage) frustrates users with disabilities',
+                            severity: 'high',
+                        });
+                        recommendations.push('Improve alt text coverage to at least 80% for better accessibility');
+                    }
+                    // ARIA support impact
+                    if (ariaLabels > 5) {
+                        score += 8;
+                        findings.push('Strong ARIA labeling enhances screen reader experience');
+                    }
+                    // Performance impact on feelings (35% weight)
+                    if (loadTime < 1500) {
+                        score += 15;
+                        findings.push('Very fast load time (<1.5s) delights users');
+                    }
+                    else if (loadTime < 2500) {
+                        score += 8;
+                        findings.push('Fast load time enhances user satisfaction');
+                    }
+                    else if (loadTime > 4000) {
+                        score -= 20;
+                        issues.push({ description: 'Very slow load time (>4s) causes significant frustration', severity: 'critical' });
+                        recommendations.push('Optimize page load time - target under 2.5 seconds');
+                    }
+                    else if (loadTime > 3000) {
+                        score -= 12;
+                        issues.push({ description: 'Slow load time causes user frustration', severity: 'high' });
+                    }
+                    // Error visibility impact
+                    if (context.errorIndicators?.hasErrorMessages) {
+                        score -= 12;
+                        issues.push({ description: 'Visible errors reduce user confidence and satisfaction', severity: 'high' });
+                        recommendations.push('Review and fix visible error messages');
+                    }
+                    // Interaction capability
+                    if (focusableElements > 20) {
+                        score += 5;
+                        findings.push('Rich interactive elements provide user control and engagement');
+                    }
+                    else if (focusableElements < 5) {
+                        score -= 8;
+                        issues.push({ description: 'Limited interactivity may feel restrictive', severity: 'medium' });
+                    }
+                    score = Math.max(20, Math.min(100, score));
+                    break;
                 }
-                score = Math.max(20, Math.min(100, score));
-                break;
             case QXHeuristic.GUI_FLOW_IMPACT:
-                const interactiveElements = context.domMetrics?.interactiveElements || 0;
-                const forms = context.domMetrics?.forms || 0;
-                if (interactiveElements > 20) {
-                    score = 75;
-                    findings.push(`${interactiveElements} interactive elements provide user control`);
-                }
-                if (forms > 0) {
-                    findings.push(`${forms} forms impact user input flows`);
-                    score = Math.min(100, score + 10);
-                }
-                if (interactiveElements === 0) {
-                    score = 30;
-                    issues.push({ description: 'Limited user interaction capability', severity: 'high' });
+                {
+                    const interactiveElements = context.domMetrics?.interactiveElements || 0;
+                    const forms = context.domMetrics?.forms || 0;
+                    if (interactiveElements > 20) {
+                        score = 75;
+                        findings.push(`${interactiveElements} interactive elements provide user control`);
+                    }
+                    if (forms > 0) {
+                        findings.push(`${forms} forms impact user input flows`);
+                        score = Math.min(100, score + 10);
+                    }
+                    if (interactiveElements === 0) {
+                        score = 30;
+                        issues.push({ description: 'Limited user interaction capability', severity: 'high' });
+                    }
+                    break;
                 }
-                break;
             case QXHeuristic.CROSS_FUNCTIONAL_IMPACT:
                 score = 70;
                 if (context.accessibility && (context.accessibility.altTextsCoverage || 0) < 100) {
@@ -232,14 +242,16 @@ export class QXHeuristicsEngine {
                 break;
             // ========== User Needs Heuristics (H2.x) ==========
             case QXHeuristic.USER_NEEDS_IDENTIFICATION:
-                score = userNeeds.alignmentScore;
-                findings.push(`${userNeeds.needs.length} user needs identified`);
-                const mustHave = userNeeds.needs.filter((n) => n.priority === 'must-have').length;
-                findings.push(`${mustHave} must-have features`);
-                if (userNeeds.challenges.length > 0) {
-                    issues.push({ description: `${userNeeds.challenges.length} user need challenges found`, severity: 'medium' });
+                {
+                    score = userNeeds.alignmentScore;
+                    findings.push(`${userNeeds.needs.length} user needs identified`);
+                    const mustHave = userNeeds.needs.filter((n) => n.priority === 'must-have').length;
+                    findings.push(`${mustHave} must-have features`);
+                    if (userNeeds.challenges.length > 0) {
+                        issues.push({ description: `${userNeeds.challenges.length} user need challenges found`, severity: 'medium' });
+                    }
+                    break;
                 }
-                break;
             case QXHeuristic.USER_NEEDS_SUITABILITY:
                 score =
                     userNeeds.suitability === 'excellent'
@@ -252,10 +264,12 @@ export class QXHeuristicsEngine {
                 findings.push(`User needs suitability: ${userNeeds.suitability}`);
                 break;
             case QXHeuristic.USER_NEEDS_VALIDATION:
-                const addressedNeeds = userNeeds.needs.filter((n) => n.addressed).length;
-                score = userNeeds.needs.length > 0 ? (addressedNeeds / userNeeds.needs.length) * 100 : 50;
-                findings.push(`${addressedNeeds}/${userNeeds.needs.length} needs validated and addressed`);
-                break;
+                {
+                    const addressedNeeds = userNeeds.needs.filter((n) => n.addressed).length;
+                    score = userNeeds.needs.length > 0 ? (addressedNeeds / userNeeds.needs.length) * 100 : 50;
+                    findings.push(`${addressedNeeds}/${userNeeds.needs.length} needs validated and addressed`);
+                    break;
+                }
             // ========== Business Needs Heuristics (H3.x) ==========
             case QXHeuristic.BUSINESS_NEEDS_IDENTIFICATION:
                 score = businessNeeds.alignmentScore;
@@ -264,16 +278,18 @@ export class QXHeuristicsEngine {
                 findings.push(`${businessNeeds.crossTeamImpact.length} cross-team impacts`);
                 break;
             case QXHeuristic.USER_VS_BUSINESS_BALANCE:
-                const balanceScore = 100 - Math.abs(userNeeds.alignmentScore - businessNeeds.alignmentScore);
-                score = balanceScore;
-                if (balanceScore > 80) {
-                    findings.push('Good balance between user and business needs');
-                }
-                else {
-                    issues.push({ description: 'Imbalance between user and business priorities', severity: 'medium' });
-                    recommendations.push('Align user and business objectives more closely');
+                {
+                    const balanceScore = 100 - Math.abs(userNeeds.alignmentScore - businessNeeds.alignmentScore);
+                    score = balanceScore;
+                    if (balanceScore > 80) {
+                        findings.push('Good balance between user and business needs');
+                    }
+                    else {
+                        issues.push({ description: 'Imbalance between user and business priorities', severity: 'medium' });
+                        recommendations.push('Align user and business objectives more closely');
+                    }
+                    break;
                 }
-                break;
             case QXHeuristic.KPI_IMPACT_ANALYSIS:
                 score = businessNeeds.impactsKPIs ? 85 : 50;
                 findings.push(`KPIs impacted: ${businessNeeds.kpisAffected.join(', ')}`);
@@ -297,18 +313,20 @@ export class QXHeuristicsEngine {
                 }
                 break;
             case QXHeuristic.SUPPORTING_DATA_ANALYSIS:
-                score = 75;
-                const hasData = (context.domMetrics?.forms || 0) > 0 || (context.domMetrics?.interactiveElements || 0) > 20;
-                if (hasData) {
-                    score = 82;
-                    findings.push('Sufficient data points for informed decision-making');
-                }
-                else {
-                    score = 60;
-                    issues.push({ description: 'Limited data for comprehensive analysis', severity: 'medium' });
-                    recommendations.push('Collect more user interaction data');
+                {
+                    score = 75;
+                    const hasData = (context.domMetrics?.forms || 0) > 0 || (context.domMetrics?.interactiveElements || 0) > 20;
+                    if (hasData) {
+                        score = 82;
+                        findings.push('Sufficient data points for informed decision-making');
+                    }
+                    else {
+                        score = 60;
+                        issues.push({ description: 'Limited data for comprehensive analysis', severity: 'medium' });
+                        recommendations.push('Collect more user interaction data');
+                    }
+                    break;
                 }
-                break;
             // ========== Creativity Heuristics (H6.x) ==========
             case QXHeuristic.COMPETITIVE_ANALYSIS:
                 score = 70;
@@ -324,27 +342,31 @@ export class QXHeuristicsEngine {
                 }
                 break;
             case QXHeuristic.DOMAIN_INSPIRATION:
-                score = 72;
-                const hasModernElements = context.accessibility && (context.accessibility.ariaLabelsCount || 0) > 0;
-                if (hasModernElements) {
-                    score = 80;
-                    findings.push('Modern accessibility patterns show domain inspiration');
-                }
-                else {
-                    recommendations.push('Research domain-specific design patterns and best practices');
+                {
+                    score = 72;
+                    const hasModernElements = context.accessibility && (context.accessibility.ariaLabelsCount || 0) > 0;
+                    if (hasModernElements) {
+                        score = 80;
+                        findings.push('Modern accessibility patterns show domain inspiration');
+                    }
+                    else {
+                        recommendations.push('Research domain-specific design patterns and best practices');
+                    }
+                    break;
                 }
-                break;
             case QXHeuristic.INNOVATIVE_SOLUTIONS:
-                score = 65;
-                const hasAdvancedFeatures = (context.accessibility?.landmarkRoles || 0) > 3;
-                if (hasAdvancedFeatures) {
-                    score = 75;
-                    findings.push('Advanced accessibility features show innovative thinking');
+                {
+                    score = 65;
+                    const hasAdvancedFeatures = (context.accessibility?.landmarkRoles || 0) > 3;
+                    if (hasAdvancedFeatures) {
+                        score = 75;
+                        findings.push('Advanced accessibility features show innovative thinking');
+                    }
+                    else {
+                        recommendations.push('Explore innovative UX patterns to differentiate experience');
+                    }
+                    break;
                 }
-                else {
-                    recommendations.push('Explore innovative UX patterns to differentiate experience');
-                }
-                break;
             default:
                 // Generic heuristic evaluation based on category
                 if (category === 'user-needs') {

package/dist/mcp/tools/visual-accessibility/index.js

@@ -258,7 +258,7 @@ export class A11yAuditTool extends MCPToolBase {
                     }
                 }
                 // Optionally check keyboard navigation
-                let keyboardViolations = [];
+                const keyboardViolations = [];
                 if (checkKeyboard) {
                     const keyboardResult = await service.checkKeyboardNavigation(url);
                     if (keyboardResult.success) {

package/dist/mcp/transport/stdio.d.ts

@@ -71,6 +71,7 @@ export declare class StdioTransport {
     private requestHandler;
     private notificationHandler;
     private errorHandler;
+    private closeHandler;
     private running;
     private metrics;
     constructor(config?: TransportConfig);
@@ -102,6 +103,12 @@ export declare class StdioTransport {
      * Set error handler for transport-level errors
      */
     onError(handler: (error: Error) => void): void;
+    /**
+     * Set handler for a terminal close (stdin EOF / parent process exited).
+     * Issue #513: lets the server shut down gracefully instead of attempting
+     * to reconnect to a stream that can never come back.
+     */
+    onClose(handler: () => void): void;
     /**
      * Reconnect the transport by re-attaching to stdin/stdout.
      * Closes the existing readline interface and creates a new one.

package/dist/mcp/transport/stdio.js

@@ -53,6 +53,7 @@ export class StdioTransport {
     requestHandler = null;
     notificationHandler = null;
     errorHandler = null;
+    closeHandler = null;
     running = false;
     metrics = {
         messagesReceived: 0,
@@ -99,8 +100,25 @@ export class StdioTransport {
         this.rl.on('close', () => {
             const wasRunning = this.running;
             this.running = false;
-            // If we were running and didn't explicitly stop, this is an unexpected close
-            if (wasRunning && this.errorHandler) {
+            if (!wasRunning) {
+                return; // explicit stop() — nothing to signal
+            }
+            // Issue #513: a readline 'close' caused by stdin reaching EOF means the
+            // parent process is gone. stdio cannot reconnect to a new parent, so
+            // this is TERMINAL — route it to the close handler and never to the
+            // error handler. Firing the error handler here triggers the reconnect
+            // path, which re-attaches readline to the already-ended stdin and
+            // busy-loops (close → error → reconnect → close ...) at high CPU.
+            const ended = this.inputStream.readableEnded === true;
+            if (ended) {
+                if (this.closeHandler) {
+                    this.closeHandler();
+                }
+                return;
+            }
+            // Stream not ended (e.g. an internal readline close without EOF):
+            // keep the legacy transient-error behavior so socket-like callers can retry.
+            if (this.errorHandler) {
                 this.errorHandler(new Error('Transport connection closed unexpectedly'));
             }
         });
@@ -147,11 +165,30 @@ export class StdioTransport {
     onError(handler) {
         this.errorHandler = handler;
     }
+    /**
+     * Set handler for a terminal close (stdin EOF / parent process exited).
+     * Issue #513: lets the server shut down gracefully instead of attempting
+     * to reconnect to a stream that can never come back.
+     */
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
     /**
      * Reconnect the transport by re-attaching to stdin/stdout.
      * Closes the existing readline interface and creates a new one.
      */
     reconnect() {
+        // Issue #513: never re-attach readline to an already-ended stdin. Doing so
+        // re-emits 'close' immediately and busy-loops. An ended input stream is
+        // terminal for stdio — signal the close handler and bail.
+        const ended = this.inputStream.readableEnded === true;
+        if (ended) {
+            this.running = false;
+            if (this.closeHandler) {
+                this.closeHandler();
+            }
+            return;
+        }
         if (this.rl) {
             this.rl.close();
             this.rl = null;

package/dist/mcp/transport/websocket/websocket-transport.js

@@ -122,6 +122,7 @@ export class WebSocketTransport extends EventEmitter {
      * Handle a manual WebSocket upgrade (for testing or custom servers)
      */
     handleUpgrade(request, socket, head) {
+        // eslint-disable-next-line no-async-promise-executor -- body is wrapped in try/catch that calls reject()
         return new Promise(async (resolve, reject) => {
             if (this.disposed) {
                 socket.write('HTTP/1.1 503 Service Unavailable\r\n\r\n');

package/dist/optimization/auto-tuner.js

@@ -303,7 +303,7 @@ export class AQEAutoTuner {
         const parameterValues = this.algorithm.suggestNextConfiguration(this.parameters, this.evaluationHistory, this.config);
         // Check if we have applicators registered for real system integration
         const hasApplicators = this.applicatorRegistry.getAll().length > 0;
-        let metricValues = {};
+        const metricValues = {};
         if (hasApplicators) {
             // REAL EVALUATION: Apply configuration to actual systems
             try {

package/dist/planning/goap-planner.js

@@ -60,6 +60,7 @@ class MinHeap {
     }
     sinkDown(i) {
         const n = this.data.length;
+        // eslint-disable-next-line no-constant-condition -- heap sift-down; loop breaks internally
         while (true) {
             let smallest = i;
             const left = 2 * i + 1;

package/dist/routing/agent-dependency-graph.js

@@ -98,7 +98,10 @@ export function parseDependenciesFromFrontmatter(content) {
             const listStart = trimmed.match(/^-\s+(\w+):\s*(.*)$/);
             if (listStart) {
                 if (st.inList) {
-                    st.section === 'agents' ? flushAgent() : flushMcp();
+                    if (st.section === 'agents')
+                        flushAgent();
+                    else
+                        flushMcp();
                 }
                 st.inList = true;
                 st.item = { [listStart[1]]: parseYamlValue(listStart[2]) };

package/dist/shared/llm/router/config-store.js

@@ -148,7 +148,7 @@ function stripApiKeys(config) {
         return JSON.parse(JSON.stringify(config));
     }
     const cloned = JSON.parse(JSON.stringify(config));
-    let strippedProviders = [];
+    const strippedProviders = [];
     if (cloned.providers) {
         for (const provider of Object.keys(cloned.providers)) {
             const entry = cloned.providers[provider];

package/dist/shared/metrics/system-metrics.js

@@ -127,10 +127,12 @@ export class SystemMetricsCollector {
                 return metrics.cpu.loadAverage[2];
             default:
                 // For unknown metrics, return from history or 0
-                const history = this.metricHistory.get(metricName);
-                return history && history.length > 0
-                    ? history[history.length - 1].value
-                    : 0;
+                {
+                    const history = this.metricHistory.get(metricName);
+                    return history && history.length > 0
+                        ? history[history.length - 1].value
+                        : 0;
+                }
         }
     }
     /**

package/dist/shared/parsers/tree-sitter-wasm-parser.d.ts

@@ -12,6 +12,7 @@
  */
 import type { SupportedLanguage } from '../types/test-frameworks.js';
 import type { ILanguageParser, ParsedFile } from './interfaces.js';
+type SyntaxNode = any;
 export declare class TreeSitterWASMParser implements ILanguageParser {
     readonly language: SupportedLanguage;
     readonly supportedExtensions: string[];
@@ -25,8 +26,19 @@ export declare function createWasmParsers(): Map<SupportedLanguage, ILanguagePar
  * Returns true if the dependency is installed; does NOT initialize WASM.
  */
 export declare function isWasmAvailable(): boolean;
+/**
+ * Generic grammar loader for callers outside the GRAMMAR_CONFIG set (e.g. the
+ * code-intelligence TS/JS extractor). Reuses the proven WASM init + grammar
+ * path resolution. Returns a `parse(code)` that yields a tree-sitter tree
+ * (caller must call `tree.delete()`), or null if WASM/grammar is unavailable so
+ * the caller can fall back.
+ */
+export declare function loadWasmGrammar(wasmFile: string): Promise<{
+    parse: (code: string) => SyntaxNode;
+} | null>;
 /**
  * Reset internal state — for testing only.
  */
 export declare function _resetWasmState(): void;
+export {};
 //# sourceMappingURL=tree-sitter-wasm-parser.d.ts.map