agentic-qe 3.10.1 → 3.10.3

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

@@ -43,6 +43,26 @@ export declare const JSON_RPC_ERRORS: {
     readonly INTERNAL_ERROR: -32603;
     readonly SERVER_ERROR: -32000;
 };
+/**
+ * Error subclass that carries a JSON-RPC error `code` so it can be surfaced as a
+ * proper JSON-RPC error response (instead of being flattened to "[object Object]").
+ * Mirrors the OAuthProviderError pattern used in the security layer.
+ */
+export declare class McpError extends Error {
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+/**
+ * Type guard for any thrown value that carries a JSON-RPC `code` + `message`.
+ * Accepts both the McpError subclass and legacy plain `{ code, message }` objects
+ * so existing throw sites continue to map to the right JSON-RPC error code.
+ */
+export declare function isJsonRpcCodedError(err: unknown): err is {
+    code: number;
+    message: string;
+    data?: unknown;
+};
 export declare class StdioTransport {
     private readonly inputStream;
     private readonly outputStream;

package/dist/mcp/transport/stdio.js

@@ -16,6 +16,32 @@ export const JSON_RPC_ERRORS = {
     INTERNAL_ERROR: -32603,
     SERVER_ERROR: -32000,
 };
+/**
+ * Error subclass that carries a JSON-RPC error `code` so it can be surfaced as a
+ * proper JSON-RPC error response (instead of being flattened to "[object Object]").
+ * Mirrors the OAuthProviderError pattern used in the security layer.
+ */
+export class McpError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'McpError';
+    }
+}
+/**
+ * Type guard for any thrown value that carries a JSON-RPC `code` + `message`.
+ * Accepts both the McpError subclass and legacy plain `{ code, message }` objects
+ * so existing throw sites continue to map to the right JSON-RPC error code.
+ */
+export function isJsonRpcCodedError(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        typeof err.code === 'number' &&
+        typeof err.message === 'string');
+}
 // ============================================================================
 // Stdio Transport Implementation
 // ============================================================================
@@ -205,8 +231,15 @@ export class StdioTransport {
             });
         }
         catch (err) {
-            const error = err;
-            await this.sendError(request.id, JSON_RPC_ERRORS.INTERNAL_ERROR, error.message || 'Internal error');
+            // Honor a JSON-RPC `code` carried by the thrown value (McpError or a legacy
+            // plain `{ code, message }` object); otherwise fall back to INTERNAL_ERROR.
+            if (isJsonRpcCodedError(err)) {
+                await this.sendError(request.id, err.code, err.message, err.data);
+            }
+            else {
+                const error = err;
+                await this.sendError(request.id, JSON_RPC_ERRORS.INTERNAL_ERROR, error.message || 'Internal error');
+            }
         }
     }
     async handleNotification(notification) {

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