@bryan-thompson/inspector-assessment 1.43.2 → 1.43.4

package/client/lib/services/assessment/AssessmentOrchestrator.js

@@ -1,78 +1,92 @@
 /**
  * Assessment Orchestrator
  * Coordinates all assessment modules and manages the assessment workflow
- *
- * @public
- * @module AssessmentOrchestrator
  */
 import { DEFAULT_ASSESSMENT_CONFIG, } from "../../lib/assessmentTypes.js";
-// Note: All assessor module imports now handled by registry/AssessorDefinitions.ts (Issue #91)
+// Core assessment modules
+import { FunctionalityAssessor } from "./modules/FunctionalityAssessor.js";
+import { SecurityAssessor } from "./modules/SecurityAssessor.js";
+import { DocumentationAssessor } from "./modules/DocumentationAssessor.js";
+import { ErrorHandlingAssessor } from "./modules/ErrorHandlingAssessor.js";
+import { UsabilityAssessor } from "./modules/UsabilityAssessor.js";
+// Extended assessment modules
+import { MCPSpecComplianceAssessor } from "./modules/MCPSpecComplianceAssessor.js";
+// New MCP Directory Compliance Gap assessors
+import { AUPComplianceAssessor } from "./modules/AUPComplianceAssessor.js";
+import { ToolAnnotationAssessor } from "./modules/ToolAnnotationAssessor.js";
+import { ProhibitedLibrariesAssessor } from "./modules/ProhibitedLibrariesAssessor.js";
+import { ManifestValidationAssessor } from "./modules/ManifestValidationAssessor.js";
+import { PortabilityAssessor } from "./modules/PortabilityAssessor.js";
 // Claude Code integration for intelligent analysis
 import { ClaudeCodeBridge, FULL_CLAUDE_CODE_CONFIG, } from "./lib/claudeCodeBridge.js";
 import { TestDataGenerator } from "./TestDataGenerator.js";
-// Structured logging
-import { createLogger, DEFAULT_LOGGING_CONFIG } from "./lib/logger.js";
-// Extracted helpers for testability
-import { determineOverallStatus, generateSummary, generateRecommendations, } from "./orchestratorHelpers.js";
-// Registry pattern for assessor management (Issue #91)
-import { AssessorRegistry, ASSESSOR_DEFINITIONS } from "./registry/index.js";
-// Module scoring for dual-key output (Issue #124)
-import { calculateModuleScore } from "../../lib/moduleScoring.js";
-/**
- * Main orchestrator class for running MCP server assessments
- *
- * @public
- * @example
- * ```typescript
- * import { AssessmentOrchestrator, AssessmentContext } from '@bryan-thompson/inspector-assessment';
- *
- * const orchestrator = new AssessmentOrchestrator();
- * const result = await orchestrator.runFullAssessment(context);
- * ```
- */
 export class AssessmentOrchestrator {
     config;
-    logger;
     startTime = 0;
     totalTestsRun = 0;
     // Claude Code Bridge for intelligent analysis
     claudeBridge;
     claudeEnabled = false;
-    // Registry for assessor management (Issue #91)
-    // Delegates construction, test count aggregation, and Claude bridge wiring
-    registry;
+    // Core assessors
+    functionalityAssessor;
+    securityAssessor;
+    documentationAssessor;
+    errorHandlingAssessor;
+    usabilityAssessor;
+    // Extended assessors
+    mcpSpecAssessor;
+    // New MCP Directory Compliance Gap assessors
+    aupComplianceAssessor;
+    toolAnnotationAssessor;
+    prohibitedLibrariesAssessor;
+    manifestValidationAssessor;
+    portabilityAssessor;
     constructor(config = {}) {
         this.config = { ...DEFAULT_ASSESSMENT_CONFIG, ...config };
-        // Initialize logger
-        this.logger = createLogger("AssessmentOrchestrator", this.config.logging ?? DEFAULT_LOGGING_CONFIG);
-        // Emit deprecation warnings for deprecated config flags
-        if (this.config.assessmentCategories?.mcpSpecCompliance !== undefined) {
-            this.logger.warn("Config flag 'mcpSpecCompliance' is deprecated. Use 'protocolCompliance' instead. " +
-                "This flag will be removed in v2.0.0.", { flag: "mcpSpecCompliance", replacement: "protocolCompliance" });
-        }
-        if (this.config.assessmentCategories?.protocolConformance !== undefined) {
-            this.logger.warn("Config flag 'protocolConformance' is deprecated. Use 'protocolCompliance' instead. " +
-                "This flag will be removed in v2.0.0.", { flag: "protocolConformance", replacement: "protocolCompliance" });
-        }
         // Initialize Claude Code Bridge if enabled in config
         if (this.config.claudeCode?.enabled) {
             this.initializeClaudeBridge(this.config.claudeCode);
         }
-        // Initialize registry and register all enabled assessors (Issue #91)
-        // The registry handles:
-        // - Conditional instantiation based on config flags
-        // - Deprecated flag OR logic (e.g., protocolCompliance supports 3 flags)
-        // - Custom setup (e.g., ToolAnnotationAssessor pattern config)
-        // - Claude bridge wiring for supporting assessors
-        this.registry = new AssessorRegistry(this.config);
-        this.registry.registerAll(ASSESSOR_DEFINITIONS);
-        // Wire up Claude bridge to registry (handles all supporting assessors)
+        // Initialize core assessors
+        this.functionalityAssessor = new FunctionalityAssessor(this.config);
+        this.securityAssessor = new SecurityAssessor(this.config);
+        this.documentationAssessor = new DocumentationAssessor(this.config);
+        this.errorHandlingAssessor = new ErrorHandlingAssessor(this.config);
+        this.usabilityAssessor = new UsabilityAssessor(this.config);
+        // Initialize extended assessors if enabled
+        if (this.config.enableExtendedAssessment) {
+            if (this.config.assessmentCategories?.mcpSpecCompliance) {
+                this.mcpSpecAssessor = new MCPSpecComplianceAssessor(this.config);
+            }
+            // Initialize new MCP Directory Compliance Gap assessors
+            if (this.config.assessmentCategories?.aupCompliance) {
+                this.aupComplianceAssessor = new AUPComplianceAssessor(this.config);
+                // Wire up Claude bridge for semantic analysis
+                if (this.claudeBridge) {
+                    this.aupComplianceAssessor.setClaudeBridge(this.claudeBridge);
+                }
+            }
+            if (this.config.assessmentCategories?.toolAnnotations) {
+                this.toolAnnotationAssessor = new ToolAnnotationAssessor(this.config);
+                // Wire up Claude bridge for behavior inference
+                if (this.claudeBridge) {
+                    this.toolAnnotationAssessor.setClaudeBridge(this.claudeBridge);
+                }
+            }
+            if (this.config.assessmentCategories?.prohibitedLibraries) {
+                this.prohibitedLibrariesAssessor = new ProhibitedLibrariesAssessor(this.config);
+            }
+            if (this.config.assessmentCategories?.manifestValidation) {
+                this.manifestValidationAssessor = new ManifestValidationAssessor(this.config);
+            }
+            if (this.config.assessmentCategories?.portability) {
+                this.portabilityAssessor = new PortabilityAssessor(this.config);
+            }
+        }
+        // Wire up Claude bridge to TestDataGenerator for intelligent test generation
         if (this.claudeBridge) {
-            this.registry.setClaudeBridge(this.claudeBridge);
             TestDataGenerator.setClaudeBridge(this.claudeBridge);
         }
-        // Set logger for TestDataGenerator diagnostic output
-        TestDataGenerator.setLogger(this.logger);
     }
     /**
      * Initialize Claude Code Bridge for intelligent analysis
@@ -80,23 +94,18 @@ export class AssessmentOrchestrator {
      */
     initializeClaudeBridge(bridgeConfig) {
         try {
-            this.claudeBridge = new ClaudeCodeBridge(bridgeConfig, this.logger);
+            this.claudeBridge = new ClaudeCodeBridge(bridgeConfig);
             this.claudeEnabled = true;
-            this.logger.info("Claude Code Bridge initialized", {
-                features: bridgeConfig.features,
-            });
+            console.log("[AssessmentOrchestrator] Claude Code Bridge initialized with features:", bridgeConfig.features);
         }
         catch (error) {
-            this.logger.warn("Failed to initialize Claude Code Bridge", {
-                error: String(error),
-            });
+            console.warn("[AssessmentOrchestrator] Failed to initialize Claude Code Bridge:", error);
             this.claudeEnabled = false;
         }
     }
     /**
      * Enable Claude Code integration programmatically
      * Call this method to enable Claude features after construction
-     * @public
      */
     enableClaudeCode(config) {
         const bridgeConfig = {
@@ -105,94 +114,160 @@ export class AssessmentOrchestrator {
             enabled: true,
         };
         this.initializeClaudeBridge(bridgeConfig);
-        // Wire up to all supporting assessors via registry
+        // Wire up to existing assessors
         if (this.claudeBridge) {
-            this.registry.setClaudeBridge(this.claudeBridge);
+            if (this.aupComplianceAssessor) {
+                this.aupComplianceAssessor.setClaudeBridge(this.claudeBridge);
+            }
+            if (this.toolAnnotationAssessor) {
+                this.toolAnnotationAssessor.setClaudeBridge(this.claudeBridge);
+            }
             TestDataGenerator.setClaudeBridge(this.claudeBridge);
         }
     }
     /**
      * Check if Claude Code integration is enabled and available
-     * @public
      */
     isClaudeEnabled() {
         return this.claudeEnabled && this.claudeBridge !== undefined;
     }
     /**
      * Get Claude Code Bridge for external access
-     * @public
      */
     getClaudeBridge() {
         return this.claudeBridge;
     }
+    /**
+     * Reset test counts for all assessors
+     */
+    resetAllTestCounts() {
+        this.functionalityAssessor.resetTestCount();
+        this.securityAssessor.resetTestCount();
+        this.documentationAssessor.resetTestCount();
+        this.errorHandlingAssessor.resetTestCount();
+        this.usabilityAssessor.resetTestCount();
+        if (this.mcpSpecAssessor) {
+            this.mcpSpecAssessor.resetTestCount();
+        }
+        // Reset new assessors
+        if (this.aupComplianceAssessor) {
+            this.aupComplianceAssessor.resetTestCount();
+        }
+        if (this.toolAnnotationAssessor) {
+            this.toolAnnotationAssessor.resetTestCount();
+        }
+        if (this.prohibitedLibrariesAssessor) {
+            this.prohibitedLibrariesAssessor.resetTestCount();
+        }
+        if (this.manifestValidationAssessor) {
+            this.manifestValidationAssessor.resetTestCount();
+        }
+        if (this.portabilityAssessor) {
+            this.portabilityAssessor.resetTestCount();
+        }
+    }
     /**
      * Run a complete assessment on an MCP server
-     * @public
      */
     async runFullAssessment(context) {
         this.startTime = Date.now();
         this.totalTestsRun = 0;
-        this.registry.resetAllTestCounts();
-        // Execute all assessors via registry (Issue #91)
-        // Registry handles:
-        // - Phase-ordered execution (Phase 0/PRE always runs first and sequentially)
-        // - Parallel vs sequential based on config.parallelTesting
-        // - JSONL events (module_started, module_progress)
-        // - Test count tracking
-        const assessmentResults = await this.registry.executeAll(context);
-        // Integrate temporal findings into security.vulnerabilities for unified view
-        if (assessmentResults.temporal?.rugPullsDetected &&
-            assessmentResults.temporal.rugPullsDetected > 0 &&
-            assessmentResults.security) {
-            for (const detail of assessmentResults.temporal.details.filter((d) => d.vulnerable)) {
-                assessmentResults.security.vulnerabilities.push(`RUG_PULL_TEMPORAL: ${detail.tool} - Tool behavior changed after invocation ${detail.firstDeviationAt}. Requires immediate manual review.`);
-            }
-        }
-        // Issue #124: Dual-key output for v2.0.0 transition
-        // Output BOTH old and new keys to maintain backward compatibility
-        // Old keys (documentation, usability, mcpSpecCompliance) will be removed in v2.0.0
-        // developerExperience (new) = documentation + usability (deprecated)
-        if (assessmentResults.documentation && assessmentResults.usability) {
-            const docScore = calculateModuleScore(assessmentResults.documentation) ?? 50;
-            const usabilityScore = calculateModuleScore(assessmentResults.usability) ?? 50;
-            const combinedStatus = determineOverallStatus({
-                documentation: assessmentResults.documentation,
-                usability: assessmentResults.usability,
-            });
-            assessmentResults.developerExperience = {
-                documentation: assessmentResults.documentation,
-                usability: assessmentResults.usability,
-                status: combinedStatus,
-                score: Math.round((docScore + usabilityScore) / 2),
-            };
-            // Emit deprecation warning for old keys
-            this.logger.warn("Output keys 'documentation' and 'usability' are deprecated. " +
-                "Use 'developerExperience' instead. These keys will be removed in v2.0.0.", {
-                deprecated: ["documentation", "usability"],
-                replacement: "developerExperience",
-            });
-        }
-        // protocolCompliance (new) = mcpSpecCompliance (deprecated)
-        if (assessmentResults.mcpSpecCompliance) {
-            assessmentResults.protocolCompliance =
-                assessmentResults.mcpSpecCompliance;
-            // Emit deprecation warning for old key
-            this.logger.warn("Output key 'mcpSpecCompliance' is deprecated. " +
-                "Use 'protocolCompliance' instead. This key will be removed in v2.0.0.", {
-                deprecated: ["mcpSpecCompliance"],
-                replacement: "protocolCompliance",
-            });
+        this.resetAllTestCounts();
+        // Run assessments in parallel if enabled
+        const assessmentPromises = [];
+        const assessmentResults = {};
+        if (this.config.parallelTesting) {
+            // Core assessments
+            assessmentPromises.push(this.functionalityAssessor
+                .assess(context)
+                .then((r) => (assessmentResults.functionality = r)), this.securityAssessor
+                .assess(context)
+                .then((r) => (assessmentResults.security = r)), this.documentationAssessor
+                .assess(context)
+                .then((r) => (assessmentResults.documentation = r)), this.errorHandlingAssessor
+                .assess(context)
+                .then((r) => (assessmentResults.errorHandling = r)), this.usabilityAssessor
+                .assess(context)
+                .then((r) => (assessmentResults.usability = r)));
+            // Extended assessments
+            if (this.mcpSpecAssessor) {
+                assessmentPromises.push(this.mcpSpecAssessor
+                    .assess(context)
+                    .then((r) => (assessmentResults.mcpSpecCompliance = r)));
+            }
+            // New MCP Directory Compliance Gap assessments
+            if (this.aupComplianceAssessor) {
+                assessmentPromises.push(this.aupComplianceAssessor
+                    .assess(context)
+                    .then((r) => (assessmentResults.aupCompliance = r)));
+            }
+            if (this.toolAnnotationAssessor) {
+                assessmentPromises.push(this.toolAnnotationAssessor
+                    .assess(context)
+                    .then((r) => (assessmentResults.toolAnnotations = r)));
+            }
+            if (this.prohibitedLibrariesAssessor) {
+                assessmentPromises.push(this.prohibitedLibrariesAssessor
+                    .assess(context)
+                    .then((r) => (assessmentResults.prohibitedLibraries = r)));
+            }
+            if (this.manifestValidationAssessor) {
+                assessmentPromises.push(this.manifestValidationAssessor
+                    .assess(context)
+                    .then((r) => (assessmentResults.manifestValidation = r)));
+            }
+            if (this.portabilityAssessor) {
+                assessmentPromises.push(this.portabilityAssessor
+                    .assess(context)
+                    .then((r) => (assessmentResults.portability = r)));
+            }
+            await Promise.all(assessmentPromises);
+        }
+        else {
+            // Sequential execution
+            assessmentResults.functionality =
+                await this.functionalityAssessor.assess(context);
+            assessmentResults.security = await this.securityAssessor.assess(context);
+            assessmentResults.documentation =
+                await this.documentationAssessor.assess(context);
+            assessmentResults.errorHandling =
+                await this.errorHandlingAssessor.assess(context);
+            assessmentResults.usability =
+                await this.usabilityAssessor.assess(context);
+            if (this.mcpSpecAssessor) {
+                assessmentResults.mcpSpecCompliance =
+                    await this.mcpSpecAssessor.assess(context);
+            }
+            // New MCP Directory Compliance Gap assessments (sequential)
+            if (this.aupComplianceAssessor) {
+                assessmentResults.aupCompliance =
+                    await this.aupComplianceAssessor.assess(context);
+            }
+            if (this.toolAnnotationAssessor) {
+                assessmentResults.toolAnnotations =
+                    await this.toolAnnotationAssessor.assess(context);
+            }
+            if (this.prohibitedLibrariesAssessor) {
+                assessmentResults.prohibitedLibraries =
+                    await this.prohibitedLibrariesAssessor.assess(context);
+            }
+            if (this.manifestValidationAssessor) {
+                assessmentResults.manifestValidation =
+                    await this.manifestValidationAssessor.assess(context);
+            }
+            if (this.portabilityAssessor) {
+                assessmentResults.portability =
+                    await this.portabilityAssessor.assess(context);
+            }
         }
         // Collect test counts from all assessors
         this.totalTestsRun = this.collectTotalTestCount();
         // Determine overall status
-        const overallStatus = determineOverallStatus(assessmentResults);
+        const overallStatus = this.determineOverallStatus(assessmentResults);
         // Generate summary and recommendations
-        const summary = generateSummary(assessmentResults);
-        const recommendations = generateRecommendations(assessmentResults);
+        const summary = this.generateSummary(assessmentResults);
+        const recommendations = this.generateRecommendations(assessmentResults);
         const executionTime = Date.now() - this.startTime;
-        // Type assertion needed because Partial<MCPDirectoryAssessment> has optional required fields
-        // When modules are skipped via --skip-modules, not all fields will be present
         return {
             serverName: context.serverName,
             assessmentDate: new Date().toISOString(),
@@ -204,19 +279,10 @@ export class AssessmentOrchestrator {
             executionTime,
             totalTestsRun: this.totalTestsRun,
             mcpProtocolVersion: this.config.mcpProtocolVersion,
-            assessmentMetadata: {
-                // Source code is available if we have a path OR loaded source files
-                sourceCodeAvailable: !!context.sourceCodePath || (context.sourceCodeFiles?.size ?? 0) > 0,
-                // Use explicit transport type, or infer from available context
-                transportType: context.transportConfig?.type ??
-                    (context.transportConfig?.url ? "streamable-http" : undefined),
-            },
         };
     }
     /**
      * Legacy assess method for backward compatibility
-     * @public
-     * @deprecated Use runFullAssessment() with AssessmentContext instead
      */
     async assess(serverName, tools, callTool, serverInfo, readmeContent, packageJson) {
         const context = {
@@ -231,21 +297,120 @@ export class AssessmentOrchestrator {
         return this.runFullAssessment(context);
     }
     collectTotalTestCount() {
-        // Delegate to registry for centralized test count aggregation (Issue #91)
-        const total = this.registry.getTotalTestCount();
-        this.logger.debug("Total test count", { total });
+        let total = 0;
+        // Get actual test counts from assessors
+        const functionalityCount = this.functionalityAssessor.getTestCount();
+        const securityCount = this.securityAssessor.getTestCount();
+        const documentationCount = this.documentationAssessor.getTestCount();
+        const errorHandlingCount = this.errorHandlingAssessor.getTestCount();
+        const usabilityCount = this.usabilityAssessor.getTestCount();
+        const mcpSpecCount = this.mcpSpecAssessor?.getTestCount() || 0;
+        // New assessor counts
+        const aupCount = this.aupComplianceAssessor?.getTestCount() || 0;
+        const annotationCount = this.toolAnnotationAssessor?.getTestCount() || 0;
+        const librariesCount = this.prohibitedLibrariesAssessor?.getTestCount() || 0;
+        const manifestCount = this.manifestValidationAssessor?.getTestCount() || 0;
+        const portabilityCount = this.portabilityAssessor?.getTestCount() || 0;
+        console.log("[AssessmentOrchestrator] Test counts by assessor:", {
+            functionality: functionalityCount,
+            security: securityCount,
+            documentation: documentationCount,
+            errorHandling: errorHandlingCount,
+            usability: usabilityCount,
+            mcpSpec: mcpSpecCount,
+            aupCompliance: aupCount,
+            toolAnnotations: annotationCount,
+            prohibitedLibraries: librariesCount,
+            manifestValidation: manifestCount,
+            portability: portabilityCount,
+        });
+        total =
+            functionalityCount +
+                securityCount +
+                documentationCount +
+                errorHandlingCount +
+                usabilityCount +
+                mcpSpecCount +
+                aupCount +
+                annotationCount +
+                librariesCount +
+                manifestCount +
+                portabilityCount;
+        console.log("[AssessmentOrchestrator] Total test count:", total);
         return total;
     }
+    determineOverallStatus(results) {
+        const statuses = [];
+        // Collect all statuses
+        Object.values(results).forEach((assessment) => {
+            if (assessment?.status) {
+                statuses.push(assessment.status);
+            }
+        });
+        // If any critical category fails, overall fails
+        if (statuses.includes("FAIL"))
+            return "FAIL";
+        // If any category needs more info, overall needs more info
+        if (statuses.includes("NEED_MORE_INFO"))
+            return "NEED_MORE_INFO";
+        // All must pass for overall pass
+        return "PASS";
+    }
+    generateSummary(results) {
+        const parts = [];
+        const totalCategories = Object.keys(results).length;
+        const passedCategories = Object.values(results).filter((r) => r?.status === "PASS").length;
+        parts.push(`Assessment complete: ${passedCategories}/${totalCategories} categories passed.`);
+        // Add key findings
+        if (results.security?.vulnerabilities?.length > 0) {
+            parts.push(`Found ${results.security.vulnerabilities.length} security vulnerabilities.`);
+        }
+        if (results.functionality?.brokenTools?.length > 0) {
+            parts.push(`${results.functionality.brokenTools.length} tools are not functioning correctly.`);
+        }
+        // New assessor findings
+        if (results.aupCompliance?.violations?.length > 0) {
+            const criticalCount = results.aupCompliance.violations.filter((v) => v.severity === "CRITICAL").length;
+            if (criticalCount > 0) {
+                parts.push(`CRITICAL: ${criticalCount} AUP violation(s) detected.`);
+            }
+            else {
+                parts.push(`${results.aupCompliance.violations.length} AUP item(s) flagged for review.`);
+            }
+        }
+        if (results.toolAnnotations?.missingAnnotationsCount > 0) {
+            parts.push(`${results.toolAnnotations.missingAnnotationsCount} tools missing annotations.`);
+        }
+        if (results.prohibitedLibraries?.matches?.length > 0) {
+            const blockingCount = results.prohibitedLibraries.matches.filter((m) => m.severity === "BLOCKING").length;
+            if (blockingCount > 0) {
+                parts.push(`BLOCKING: ${blockingCount} prohibited library/libraries detected.`);
+            }
+        }
+        if (results.portability?.usesBundleRoot) {
+            parts.push("Uses ${BUNDLE_ROOT} anti-pattern.");
+        }
+        return parts.join(" ");
+    }
+    generateRecommendations(results) {
+        const recommendations = [];
+        // Aggregate recommendations from all assessments
+        Object.values(results).forEach((assessment) => {
+            if (assessment?.recommendations) {
+                recommendations.push(...assessment.recommendations);
+            }
+        });
+        // De-duplicate and prioritize
+        return [...new Set(recommendations)].slice(0, 10);
+    }
     /**
      * Get assessment configuration
-     * @public
      */
     getConfig() {
         return this.config;
     }
     /**
      * Update assessment configuration
-     * @public
      */
     updateConfig(config) {
         this.config = { ...this.config, ...config };

package/client/lib/services/assessment/modules/ErrorHandlingAssessor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Error Handling Assessor Module
+ * Tests error handling and input validation
+ */
+import { ErrorHandlingAssessment } from "../../../lib/assessmentTypes.js";
+import { BaseAssessor } from "./BaseAssessor.js";
+import { AssessmentContext } from "../AssessmentOrchestrator.js";
+export declare class ErrorHandlingAssessor extends BaseAssessor {
+    assess(context: AssessmentContext): Promise<ErrorHandlingAssessment>;
+    private selectToolsForTesting;
+    private testToolErrorHandling;
+    private testMissingParameters;
+    private testWrongTypes;
+    private testInvalidValues;
+    private testExcessiveInput;
+    private getToolSchema;
+    private generateWrongTypeParams;
+    private generateInvalidValueParams;
+    private generateParamsWithValue;
+    private calculateMetrics;
+    private determineErrorHandlingStatus;
+    private generateExplanation;
+    private generateRecommendations;
+}
+//# sourceMappingURL=ErrorHandlingAssessor.d.ts.map

package/client/lib/services/assessment/modules/ErrorHandlingAssessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorHandlingAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/ErrorHandlingAssessor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,uBAAuB,EAIxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,qBAAa,qBAAsB,SAAQ,YAAY;IAC/C,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAyC1E,OAAO,CAAC,qBAAqB;YA8Cf,qBAAqB;YAuBrB,qBAAqB;YAmGrB,cAAc;YAmFd,iBAAiB;YA8DjB,kBAAkB;IA6DhC,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,uBAAuB;IAgC/B,OAAO,CAAC,0BAA0B;IAgClC,OAAO,CAAC,uBAAuB;IA4B/B,OAAO,CAAC,gBAAgB;IAoGxB,OAAO,CAAC,4BAA4B;IAapC,OAAO,CAAC,mBAAmB;IAuE3B,OAAO,CAAC,uBAAuB;CA4ChC"}

package/client/lib/services/assessment/modules/ErrorHandlingAssessor.deprecated.js

@@ -10,7 +10,7 @@
  * @module assessment/modules/ErrorHandlingAssessor
  */
 import { BaseAssessor } from "./BaseAssessor.js";
-import { ProtocolComplianceAssessor } from "./ProtocolComplianceAssessor.js";
+import { ProtocolComplianceAssessor } from "./ProtocolComplianceAssessor/index.js";
 /**
  * @deprecated Use ProtocolComplianceAssessor instead.
  *