@bryan-thompson/inspector-assessment-client 1.25.4 → 1.25.5

package/lib/services/assessment/lib/concurrencyLimit.js

@@ -2,6 +2,7 @@
  * Simple concurrency limiter for parallel async operations
  * Provides the same interface as p-limit but is CJS-compatible
  */
+import { DEFAULT_PERFORMANCE_CONFIG } from "../config/performanceConfig.js";
 /**
  * Warning threshold for queue depth monitoring.
  * If queue exceeds this size, a warning is emitted to help diagnose
@@ -12,13 +13,16 @@
  *
  * Threshold of 10,000 provides ~146% headroom to accommodate larger
  * tool sets while catching true runaway scenarios.
+ *
+ * @see PerformanceConfig.queueWarningThreshold (Issue #37)
  */
-export const QUEUE_WARNING_THRESHOLD = 10000;
+export const QUEUE_WARNING_THRESHOLD = DEFAULT_PERFORMANCE_CONFIG.queueWarningThreshold;
 /**
  * Creates a concurrency limiter that allows only a specified number
  * of async operations to run simultaneously
  *
  * @param concurrency - Maximum number of concurrent operations
+ * @param logger - Optional logger instance for queue depth warnings
  * @returns A function that wraps async operations with the concurrency limit
  *
  * @example
@@ -27,7 +31,7 @@ export const QUEUE_WARNING_THRESHOLD = 10000;
  *   items.map(item => limit(() => processItem(item)))
  * );
  */
-export function createConcurrencyLimit(concurrency) {
+export function createConcurrencyLimit(concurrency, logger) {
     if (concurrency < 1) {
         throw new Error("Concurrency must be at least 1");
     }
@@ -62,10 +66,13 @@ export function createConcurrencyLimit(concurrency) {
             // Only warn once per limiter instance to avoid log spam
             if (queue.length > QUEUE_WARNING_THRESHOLD && !hasWarned) {
                 hasWarned = true;
-                console.warn(`[concurrencyLimit] Queue depth: ${queue.length} ` +
-                    `(threshold: ${QUEUE_WARNING_THRESHOLD}). ` +
-                    `Active: ${activeCount}/${concurrency}. ` +
-                    `This may indicate a slow/stalled server.`);
+                logger?.warn("Queue depth exceeded threshold", {
+                    queueDepth: queue.length,
+                    threshold: QUEUE_WARNING_THRESHOLD,
+                    activeCount,
+                    concurrency,
+                    message: "This may indicate a slow/stalled server",
+                });
             }
             next();
         });

package/lib/services/assessment/lib/errors.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Assessment Error Types
+ *
+ * Provides standardized error handling across all assessment modules.
+ * See docs/ERROR_HANDLING_CONVENTIONS.md for usage guidelines.
+ */
+/**
+ * Error categories for classification and debugging
+ */
+export declare enum ErrorCategory {
+    /** Network connectivity issues (ECONNREFUSED, DNS failures, etc.) */
+    CONNECTION = "CONNECTION",
+    /** MCP protocol violations or unexpected responses */
+    PROTOCOL = "PROTOCOL",
+    /** Input validation failures (invalid parameters, missing fields) */
+    VALIDATION = "VALIDATION",
+    /** Operation exceeded time limit */
+    TIMEOUT = "TIMEOUT",
+    /** JSON or data parsing failures */
+    PARSE = "PARSE",
+    /** Unclassified errors */
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Custom error class for assessment operations
+ *
+ * @example
+ * throw new AssessmentError(
+ *   'Failed to connect to MCP server',
+ *   ErrorCategory.CONNECTION,
+ *   false, // not recoverable
+ *   { url: 'http://localhost:3000', attempt: 3 }
+ * );
+ */
+export declare class AssessmentError extends Error {
+    readonly code: ErrorCategory;
+    readonly recoverable: boolean;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, code: ErrorCategory, recoverable?: boolean, context?: Record<string, unknown>);
+    /**
+     * Create a structured object for serialization
+     */
+    toJSON(): ErrorInfo;
+}
+/**
+ * Structured error information for result objects
+ */
+export interface ErrorInfo {
+    /** Human-readable error message */
+    message: string;
+    /** Error category for classification */
+    code: ErrorCategory;
+    /** Whether the operation can be retried */
+    recoverable: boolean;
+    /** Stack trace (optional, for debugging) */
+    stack?: string;
+    /** Additional context about the error */
+    context?: Record<string, unknown>;
+}
+/**
+ * Interface for result objects that may contain errors
+ *
+ * @example
+ * interface ToolTestResult extends ErrorResult {
+ *   toolName: string;
+ *   passed: boolean;
+ * }
+ */
+export interface ErrorResult {
+    error?: ErrorInfo;
+}
+/**
+ * Type guard to check if a value is an AssessmentError
+ */
+export declare function isAssessmentError(error: unknown): error is AssessmentError;
+/**
+ * Categorize an error based on its message content
+ *
+ * @param error - The error to categorize
+ * @returns The appropriate ErrorCategory
+ */
+export declare function categorizeError(error: unknown): ErrorCategory;
+/**
+ * Extract error message from various error types
+ *
+ * @param error - The error to extract message from
+ * @returns A string error message
+ */
+export declare function extractErrorMessage(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/lib/services/assessment/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/lib/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,oBAAY,aAAa;IACvB,qEAAqE;IACrE,UAAU,eAAe;IACzB,sDAAsD;IACtD,QAAQ,aAAa;IACrB,qEAAqE;IACrE,UAAU,eAAe;IACzB,oCAAoC;IACpC,OAAO,YAAY;IACnB,oCAAoC;IACpC,KAAK,UAAU;IACf,0BAA0B;IAC1B,OAAO,YAAY;CACpB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,SAAQ,KAAK;aAGtB,IAAI,EAAE,aAAa;aACnB,WAAW,EAAE,OAAO;aACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAHjD,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,aAAa,EACnB,WAAW,GAAE,OAAc,EAC3B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAUnD;;OAEG;IACH,MAAM,IAAI,SAAS;CASpB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,IAAI,EAAE,aAAa,CAAC;IACpB,2CAA2C;IAC3C,WAAW,EAAE,OAAO,CAAC;IACrB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE1E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAsC7D;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAwB1D"}

package/lib/services/assessment/lib/errors.js

@@ -0,0 +1,136 @@
+/**
+ * Assessment Error Types
+ *
+ * Provides standardized error handling across all assessment modules.
+ * See docs/ERROR_HANDLING_CONVENTIONS.md for usage guidelines.
+ */
+/**
+ * Error categories for classification and debugging
+ */
+export var ErrorCategory;
+(function (ErrorCategory) {
+    /** Network connectivity issues (ECONNREFUSED, DNS failures, etc.) */
+    ErrorCategory["CONNECTION"] = "CONNECTION";
+    /** MCP protocol violations or unexpected responses */
+    ErrorCategory["PROTOCOL"] = "PROTOCOL";
+    /** Input validation failures (invalid parameters, missing fields) */
+    ErrorCategory["VALIDATION"] = "VALIDATION";
+    /** Operation exceeded time limit */
+    ErrorCategory["TIMEOUT"] = "TIMEOUT";
+    /** JSON or data parsing failures */
+    ErrorCategory["PARSE"] = "PARSE";
+    /** Unclassified errors */
+    ErrorCategory["UNKNOWN"] = "UNKNOWN";
+})(ErrorCategory || (ErrorCategory = {}));
+/**
+ * Custom error class for assessment operations
+ *
+ * @example
+ * throw new AssessmentError(
+ *   'Failed to connect to MCP server',
+ *   ErrorCategory.CONNECTION,
+ *   false, // not recoverable
+ *   { url: 'http://localhost:3000', attempt: 3 }
+ * );
+ */
+export class AssessmentError extends Error {
+    code;
+    recoverable;
+    context;
+    constructor(message, code, recoverable = true, context) {
+        super(message);
+        this.code = code;
+        this.recoverable = recoverable;
+        this.context = context;
+        this.name = "AssessmentError";
+        // Maintains proper stack trace in V8 environments
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, AssessmentError);
+        }
+    }
+    /**
+     * Create a structured object for serialization
+     */
+    toJSON() {
+        return {
+            message: this.message,
+            code: this.code,
+            recoverable: this.recoverable,
+            stack: this.stack,
+            context: this.context,
+        };
+    }
+}
+/**
+ * Type guard to check if a value is an AssessmentError
+ */
+export function isAssessmentError(error) {
+    return error instanceof AssessmentError;
+}
+/**
+ * Categorize an error based on its message content
+ *
+ * @param error - The error to categorize
+ * @returns The appropriate ErrorCategory
+ */
+export function categorizeError(error) {
+    const message = extractErrorMessage(error).toLowerCase();
+    if (message.includes("timeout") || message.includes("timed out")) {
+        return ErrorCategory.TIMEOUT;
+    }
+    if (message.includes("connection") ||
+        message.includes("econnrefused") ||
+        message.includes("enotfound") ||
+        message.includes("network")) {
+        return ErrorCategory.CONNECTION;
+    }
+    if (message.includes("parse") ||
+        message.includes("json") ||
+        message.includes("syntax")) {
+        return ErrorCategory.PARSE;
+    }
+    if (message.includes("protocol") ||
+        message.includes("mcp") ||
+        message.includes("invalid response")) {
+        return ErrorCategory.PROTOCOL;
+    }
+    if (message.includes("invalid") ||
+        message.includes("required") ||
+        message.includes("missing") ||
+        message.includes("validation")) {
+        return ErrorCategory.VALIDATION;
+    }
+    return ErrorCategory.UNKNOWN;
+}
+/**
+ * Extract error message from various error types
+ *
+ * @param error - The error to extract message from
+ * @returns A string error message
+ */
+export function extractErrorMessage(error) {
+    if (typeof error === "string") {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (error && typeof error === "object") {
+        const err = error;
+        if (typeof err.message === "string") {
+            return err.message;
+        }
+        if (typeof err.error === "string") {
+            return err.error;
+        }
+        if (err.error && typeof err.error === "object") {
+            return extractErrorMessage(err.error);
+        }
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}

package/lib/services/assessment/lib/timeoutUtils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Timeout Utilities for Assessment Operations
+ *
+ * Provides AbortController-based timeout handling with proper cleanup.
+ * Fixes GitHub issue #38: Promise.race patterns that leave timers hanging.
+ *
+ * Key improvements over basic Promise.race:
+ * 1. Clears setTimeout when operation completes (prevents timer leaks)
+ * 2. Uses AbortController for signal-based cancellation
+ * 3. Provides consistent error messages
+ */
+export interface TimeoutOptions {
+    /** Timeout in milliseconds */
+    timeoutMs: number;
+    /** Optional custom error message for timeout */
+    errorMessage?: string;
+}
+/**
+ * Execute a promise with timeout and proper cleanup.
+ *
+ * This function wraps any promise with a timeout, ensuring the timer
+ * is always cleaned up whether the operation succeeds, fails, or times out.
+ *
+ * @param promise - The promise to execute
+ * @param options - Timeout configuration
+ * @returns The result of the promise
+ * @throws Error if operation times out
+ *
+ * @example Basic usage
+ * ```typescript
+ * const result = await executeWithTimeout(
+ *   callTool(tool.name, params),
+ *   { timeoutMs: 5000 }
+ * );
+ * ```
+ *
+ * @example With custom error message
+ * ```typescript
+ * const result = await executeWithTimeout(
+ *   fetchData(),
+ *   { timeoutMs: 10000, errorMessage: "Data fetch timed out" }
+ * );
+ * ```
+ */
+export declare function executeWithTimeout<T>(promise: Promise<T>, options: TimeoutOptions): Promise<T>;
+/**
+ * Execute an async function with timeout and AbortSignal support.
+ *
+ * This variant accepts a function that receives an AbortSignal, enabling
+ * cancellation of fetch requests and other abortable operations.
+ *
+ * @param fn - Function that accepts an AbortSignal and returns a Promise
+ * @param options - Timeout configuration
+ * @returns The result of the function
+ * @throws Error if operation times out
+ *
+ * @example With fetch
+ * ```typescript
+ * const data = await executeWithTimeoutAndSignal(
+ *   async (signal) => {
+ *     const response = await fetch(url, { signal });
+ *     return response.json();
+ *   },
+ *   { timeoutMs: 5000 }
+ * );
+ * ```
+ */
+export declare function executeWithTimeoutAndSignal<T>(fn: (signal: AbortSignal) => Promise<T>, options: TimeoutOptions): Promise<T>;
+//# sourceMappingURL=timeoutUtils.d.ts.map

package/lib/services/assessment/lib/timeoutUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeoutUtils.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/lib/timeoutUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,CAAC,CAAC,CA2BZ;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,2BAA2B,CAAC,CAAC,EACjD,EAAE,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EACvC,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,CAAC,CAAC,CAqBZ"}

package/lib/services/assessment/lib/timeoutUtils.js

@@ -0,0 +1,103 @@
+/**
+ * Timeout Utilities for Assessment Operations
+ *
+ * Provides AbortController-based timeout handling with proper cleanup.
+ * Fixes GitHub issue #38: Promise.race patterns that leave timers hanging.
+ *
+ * Key improvements over basic Promise.race:
+ * 1. Clears setTimeout when operation completes (prevents timer leaks)
+ * 2. Uses AbortController for signal-based cancellation
+ * 3. Provides consistent error messages
+ */
+/**
+ * Execute a promise with timeout and proper cleanup.
+ *
+ * This function wraps any promise with a timeout, ensuring the timer
+ * is always cleaned up whether the operation succeeds, fails, or times out.
+ *
+ * @param promise - The promise to execute
+ * @param options - Timeout configuration
+ * @returns The result of the promise
+ * @throws Error if operation times out
+ *
+ * @example Basic usage
+ * ```typescript
+ * const result = await executeWithTimeout(
+ *   callTool(tool.name, params),
+ *   { timeoutMs: 5000 }
+ * );
+ * ```
+ *
+ * @example With custom error message
+ * ```typescript
+ * const result = await executeWithTimeout(
+ *   fetchData(),
+ *   { timeoutMs: 10000, errorMessage: "Data fetch timed out" }
+ * );
+ * ```
+ */
+export async function executeWithTimeout(promise, options) {
+    const { timeoutMs, errorMessage } = options;
+    // Create abort controller for timeout signaling
+    const controller = new AbortController();
+    // Set up timeout that triggers abort
+    const timeoutId = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    // Create timeout promise that rejects when abort signal fires
+    const timeoutPromise = new Promise((_, reject) => {
+        controller.signal.addEventListener("abort", () => {
+            reject(new Error(errorMessage ?? `Operation timed out after ${timeoutMs}ms`));
+        });
+    });
+    try {
+        // Race the operation against timeout
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        // CRITICAL: Always clean up timer to prevent leaks
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Execute an async function with timeout and AbortSignal support.
+ *
+ * This variant accepts a function that receives an AbortSignal, enabling
+ * cancellation of fetch requests and other abortable operations.
+ *
+ * @param fn - Function that accepts an AbortSignal and returns a Promise
+ * @param options - Timeout configuration
+ * @returns The result of the function
+ * @throws Error if operation times out
+ *
+ * @example With fetch
+ * ```typescript
+ * const data = await executeWithTimeoutAndSignal(
+ *   async (signal) => {
+ *     const response = await fetch(url, { signal });
+ *     return response.json();
+ *   },
+ *   { timeoutMs: 5000 }
+ * );
+ * ```
+ */
+export async function executeWithTimeoutAndSignal(fn, options) {
+    const { timeoutMs, errorMessage } = options;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    try {
+        return await fn(controller.signal);
+    }
+    catch (error) {
+        // Convert AbortError to timeout error for consistency
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error(errorMessage ?? `Operation timed out after ${timeoutMs}ms`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}

package/lib/services/assessment/modules/BaseAssessor.d.ts

@@ -5,10 +5,12 @@
 import { AssessmentConfiguration, AssessmentStatus } from "../../../lib/assessmentTypes.js";
 import { AssessmentContext } from "../AssessmentOrchestrator.js";
 import { Logger } from "../lib/logger.js";
+import { ErrorResult } from "../lib/errors.js";
 export declare abstract class BaseAssessor<T = unknown> {
     protected config: AssessmentConfiguration;
     protected logger: Logger;
     protected testCount: number;
+    private deprecationWarningsEmitted;
     constructor(config: AssessmentConfiguration);
     /**
      * Abstract method that each assessor must implement
@@ -20,14 +22,39 @@ export declare abstract class BaseAssessor<T = unknown> {
     protected determineStatus(passed: number, total: number, threshold?: number): AssessmentStatus;
     /**
      * Log assessment progress
-     * @deprecated Use this.logger.info() directly for structured logging with context
+     * @deprecated Use this.logger.info() directly for structured logging with context. Will be removed in v2.0.0.
      */
     protected log(message: string): void;
     /**
-     * Log error
-     * @deprecated Use this.logger.error() directly for structured logging with context
+     * Log error with optional context
+     * @deprecated Use this.logger.error() directly for structured logging with context. Will be removed in v2.0.0.
+     *
+     * @param message - Description of what operation failed
+     * @param error - The error that occurred (optional)
      */
     protected logError(message: string, error?: unknown): void;
+    /**
+     * Handle an error with logging and structured result
+     *
+     * Use this method in catch blocks to ensure consistent error handling:
+     * 1. Logs the error with context
+     * 2. Categorizes the error automatically
+     * 3. Returns a structured result with error info
+     *
+     * @param error - The caught error
+     * @param context - Description of what operation failed
+     * @param defaults - Default values to merge into result
+     * @returns A result object with error information
+     *
+     * @example
+     * try {
+     *   const result = await this.callTool(tool);
+     *   return { passed: true, result };
+     * } catch (error) {
+     *   return this.handleError(error, `Failed to call tool ${tool.name}`, { passed: false });
+     * }
+     */
+    protected handleError<T extends ErrorResult>(error: unknown, context: string, defaults?: Partial<T>): T;
     /**
      * Get test count for this assessor
      */
@@ -45,17 +72,25 @@ export declare abstract class BaseAssessor<T = unknown> {
      */
     protected sleep(ms: number): Promise<void>;
     /**
-     * Execute with timeout
+     * Execute with timeout and proper cleanup.
+     *
+     * Uses AbortController-based timeout handling that clears the timer
+     * when the operation completes, preventing timer leaks.
+     *
+     * @param promise - The promise to execute
+     * @param timeoutMs - Timeout in milliseconds (defaults to config.testTimeout)
+     * @returns The result of the promise
+     * @throws Error if operation times out
      */
     protected executeWithTimeout<T>(promise: Promise<T>, timeoutMs?: number): Promise<T>;
     /**
      * Safe JSON parse with error handling
      */
-    protected safeJsonParse(text: string): any;
+    protected safeJsonParse(text: string): unknown;
     /**
      * Extract error message from various error types
      */
-    protected extractErrorMessage(error: any): string;
+    protected extractErrorMessage(error: unknown): string;
     /**
      * Check if a response indicates an error
      * Handles various MCP response formats
@@ -63,11 +98,11 @@ export declare abstract class BaseAssessor<T = unknown> {
      * @param response - The response to check
      * @param strictMode - If true, only check explicit error indicators (default: false)
      */
-    protected isErrorResponse(response: any, strictMode?: boolean): boolean;
+    protected isErrorResponse(response: unknown, strictMode?: boolean): boolean;
     /**
      * Extract error information from a response
      */
-    protected extractErrorInfo(response: any): {
+    protected extractErrorInfo(response: unknown): {
         code?: string | number;
         message?: string;
     };

package/lib/services/assessment/modules/BaseAssessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/BaseAssessor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAwC,MAAM,eAAe,CAAC;AAE7E,8BAAsB,YAAY,CAAC,CAAC,GAAG,OAAO;IAC5C,SAAS,CAAC,MAAM,EAAE,uBAAuB,CAAC;IAC1C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,SAAS,EAAE,MAAM,CAAK;gBAEpB,MAAM,EAAE,uBAAuB;IAS3C;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,CAAC,CAAC;IAEvD;;OAEG;IACH,SAAS,CAAC,eAAe,CACvB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAY,GACtB,gBAAgB;IAUnB;;;OAGG;IACH,SAAS,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIpC;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI;IAI1D;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;OAEG;IACH,SAAS,CAAC,gBAAgB,CACxB,OAAO,EAAE,MAAM,uBAAuB,CAAC,sBAAsB,CAAC,GAC7D,OAAO;IAIV;;OAEG;cACa,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD;;OAEG;cACa,kBAAkB,CAAC,CAAC,EAClC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,GAAE,MAAgC,GAC1C,OAAO,CAAC,CAAC,CAAC;IAWb;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG;IAS1C;;OAEG;IACH,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM;IAejD;;;;;;OAMG;IACH,SAAS,CAAC,eAAe,CACvB,QAAQ,EAAE,GAAG,EACb,UAAU,GAAE,OAAe,GAC1B,OAAO;IA8CV;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,GAAG,GAAG;QACzC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;CAqBF"}
+{"version":3,"file":"BaseAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/BaseAssessor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAEjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAwC,MAAM,eAAe,CAAC;AAC7E,OAAO,EAGL,WAAW,EAEZ,MAAM,eAAe,CAAC;AAGvB,8BAAsB,YAAY,CAAC,CAAC,GAAG,OAAO;IAC5C,SAAS,CAAC,MAAM,EAAE,uBAAuB,CAAC;IAC1C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,SAAS,EAAE,MAAM,CAAK;IAGhC,OAAO,CAAC,0BAA0B,CAGhC;gBAEU,MAAM,EAAE,uBAAuB;IAS3C;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,CAAC,CAAC;IAEvD;;OAEG;IACH,SAAS,CAAC,eAAe,CACvB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAY,GACtB,gBAAgB;IAUnB;;;OAGG;IACH,SAAS,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAWpC;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI;IAW1D;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,CAAC,WAAW,CAAC,CAAC,SAAS,WAAW,EACzC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,OAAO,CAAC,CAAC,CAAM,GACxB,CAAC;IAsBJ;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;OAEG;IACH,SAAS,CAAC,gBAAgB,CACxB,OAAO,EAAE,MAAM,uBAAuB,CAAC,sBAAsB,CAAC,GAC7D,OAAO;IAIV;;OAEG;cACa,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD;;;;;;;;;;OAUG;cACa,kBAAkB,CAAC,CAAC,EAClC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,GAAE,MAAgC,GAC1C,OAAO,CAAC,CAAC,CAAC;IAOb;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS9C;;OAEG;IACH,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAgBrD;;;;;;OAMG;IACH,SAAS,CAAC,eAAe,CACvB,QAAQ,EAAE,OAAO,EACjB,UAAU,GAAE,OAAe,GAC1B,OAAO;IA+CV;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,OAAO,GAAG;QAC7C,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;CA2BF"}