@dollhousemcp/mcp-server 2.0.0-rc.5 → 2.0.0

package/dist/handlers/mcp-aql/UnifiedEndpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UnifiedEndpoint.d.ts","sourceRoot":"","sources":["../../../src/handlers/mcp-aql/UnifiedEndpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,WAAW,EAAuD,MAAM,YAAY,CAAC;AAI/G;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAEzD;;;;;;;;;;;OAWG;IACG,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,GAAG,WAAW,CAAC;IAuEpE;;;;;;OAMG;YACW,cAAc;IAuB5B;;;OAGG;IACH,OAAO,CAAC,SAAS;IAQjB;;OAEG;IACH,OAAO,CAAC,OAAO;CAOhB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAqCzC"}
+{"version":3,"file":"UnifiedEndpoint.d.ts","sourceRoot":"","sources":["../../../src/handlers/mcp-aql/UnifiedEndpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,WAAW,EAA6E,MAAM,YAAY,CAAC;AAIrI;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAEzD;;;;;;;;;;;OAWG;IACG,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,GAAG,WAAW,CAAC;IAwEpE;;;;;;OAMG;YACW,cAAc;IAuB5B;;;OAGG;IACH,OAAO,CAAC,SAAS;IAQjB;;OAEG;IACH,OAAO,CAAC,OAAO;CAOhB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAqCzC"}

package/dist/handlers/mcp-aql/UnifiedEndpoint.js

@@ -22,7 +22,7 @@
  * - Full audit logging for all operations
  */
 import { getRoute } from './OperationRouter.js';
-import { isOperationInput, parseOperationInput } from './types.js';
+import { isOperationInput, parseOperationInput, describeInvalidInput } from './types.js';
 import { logger } from '../../utils/logger.js';
 import { SecurityMonitor } from '../../security/securityMonitor.js';
 /**
@@ -66,7 +66,8 @@ export class UnifiedEndpoint {
             // Step 1: Validate and normalize input structure (supports silent JSON fallback)
             const parsedInput = parseOperationInput(input);
             if (!parsedInput) {
-                return this.failure('Invalid input: expected OperationInput with operation name and optional params', startTime);
+                return this.failure('Invalid input: expected OperationInput with operation name and optional params. ' +
+                    describeInvalidInput(input), startTime);
             }
             const { operation } = parsedInput;
             // Step 2: Determine the correct CRUD endpoint for this operation
@@ -204,4 +205,4 @@ export function getOperationHelp() {
 - abort_execution: Abort a running execution
 `.trim();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UnifiedEndpoint.js","sourceRoot":"","sources":["../../../src/handlers/mcp-aql/UnifiedEndpoint.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * UnifiedEndpoint - Single unified MCP-AQL endpoint handler (Issue #196)\n *\n * This handler provides a single `mcp_aql` endpoint as an alternative to the\n * 4 CRUD endpoints for users who want minimal token footprint (~300-400 tokens\n * vs ~943 tokens for 4 endpoints).\n *\n * ARCHITECTURE:\n * - Single entry point for all MCP-AQL operations\n * - Routes internally to appropriate MCPAQLHandler methods\n * - Uses Gatekeeper (PermissionGuard) for all permission checks\n * - Maintains full security with minimal client-side footprint\n *\n * USE CASES:\n * - Multi-server deployments where token budget is constrained\n * - Clients that prefer simpler tool interfaces\n * - Integration scenarios where 4 endpoints create complexity\n *\n * SECURITY:\n * - All operations pass through PermissionGuard.validate()\n * - Operation routing is determined server-side, not client-side\n * - Full audit logging for all operations\n */\n\nimport { MCPAQLHandler } from './MCPAQLHandler.js';\nimport { getRoute, CRUDEndpoint } from './OperationRouter.js';\nimport { OperationResult, BatchResult, ResponseMeta, isOperationInput, parseOperationInput } from './types.js';\nimport { logger } from '../../utils/logger.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\n\n/**\n * UnifiedEndpoint - Single entry point for all MCP-AQL operations\n *\n * This class wraps MCPAQLHandler to provide a unified endpoint that\n * automatically routes operations to the correct CRUD handler based\n * on the operation name.\n *\n * SECURITY NOTE:\n * Unlike the 4-endpoint mode where the client chooses which endpoint to call,\n * in single-endpoint mode the server determines the appropriate handler\n * based on the operation name. This means:\n * 1. The client cannot bypass security by calling the wrong endpoint\n * 2. All routing is enforced server-side via PermissionGuard\n * 3. The operation-to-endpoint mapping is authoritative\n */\nexport class UnifiedEndpoint {\n  constructor(private readonly mcpAqlHandler: MCPAQLHandler) {}\n\n  /**\n   * Handle any MCP-AQL operation through the unified endpoint.\n   *\n   * This method:\n   * 1. Validates input structure\n   * 2. Determines the correct CRUD endpoint for the operation\n   * 3. Routes to the appropriate handler method\n   * 4. Returns standardized OperationResult or BatchResult\n   *\n   * @param input - Operation input with operation name and params, or BatchRequest\n   * @returns OperationResult or BatchResult with success/failure status\n   */\n  async handle(input: unknown): Promise<OperationResult | BatchResult> {\n    // Issue #301: Capture start time for response timing metadata\n    const startTime = performance.now();\n\n    // Extract operation name for logging (safe access before validation)\n    const operationName = isOperationInput(input) ? input.operation : 'unknown';\n\n    try {\n      // Step 1: Validate and normalize input structure (supports silent JSON fallback)\n      const parsedInput = parseOperationInput(input);\n      if (!parsedInput) {\n        return this.failure(\n          'Invalid input: expected OperationInput with operation name and optional params',\n          startTime\n        );\n      }\n\n      const { operation } = parsedInput;\n\n      // Step 2: Determine the correct CRUD endpoint for this operation\n      const route = getRoute(operation);\n      if (!route) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'UPDATE_SECURITY_VIOLATION',\n          severity: 'MEDIUM',\n          source: 'UnifiedEndpoint.handle',\n          details: `Unknown operation: \"${operation}\"`,\n          additionalData: { operation }\n        });\n        return this.failure(\n          `Unknown operation: \"${operation}\". See tool description for available operations.`,\n          startTime\n        );\n      }\n\n      // Step 3: Route to the appropriate handler method\n      // The handler will perform its own PermissionGuard validation\n      // Pass parsedInput to ensure normalized format is used\n      const result = await this.routeToHandler(route.endpoint, parsedInput);\n\n      // Log successful routing\n      SecurityMonitor.logSecurityEvent({\n        type: 'ELEMENT_CREATED',\n        severity: 'LOW',\n        source: 'UnifiedEndpoint.handle',\n        details: `Operation '${operation}' routed to ${route.endpoint} handler`,\n        additionalData: { operation, endpoint: route.endpoint }\n      });\n\n      return result;\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n\n      SecurityMonitor.logSecurityEvent({\n        type: 'UPDATE_SECURITY_VIOLATION',\n        severity: 'MEDIUM',\n        source: 'UnifiedEndpoint.handle',\n        details: `Operation '${operationName}' failed: ${message}`,\n        additionalData: { operation: operationName, error: message }\n      });\n\n      logger.error('UnifiedEndpoint operation failed', {\n        operation: operationName,\n        error: message,\n        stack: error instanceof Error ? error.stack : undefined,\n      });\n\n      return this.failure(message, startTime);\n    }\n  }\n\n  /**\n   * Route input to the appropriate CRUD handler based on endpoint type.\n   *\n   * @param endpoint - The CRUD endpoint determined from operation routing\n   * @param input - The validated operation input\n   * @returns OperationResult or BatchResult from the handler\n   */\n  private async routeToHandler(\n    endpoint: CRUDEndpoint,\n    input: unknown\n  ): Promise<OperationResult | BatchResult> {\n    switch (endpoint) {\n      case 'CREATE':\n        return this.mcpAqlHandler.handleCreate(input);\n      case 'READ':\n        return this.mcpAqlHandler.handleRead(input);\n      case 'UPDATE':\n        return this.mcpAqlHandler.handleUpdate(input);\n      case 'DELETE':\n        return this.mcpAqlHandler.handleDelete(input);\n      case 'EXECUTE':\n        return this.mcpAqlHandler.handleExecute(input);\n      default: {\n        // Exhaustive check - TypeScript will error if a case is missing\n        const _exhaustive: never = endpoint;\n        return _exhaustive;\n      }\n    }\n  }\n\n  /**\n   * Build response metadata with correlation ID and timing.\n   * Issue #301: Request correlation support.\n   */\n  private buildMeta(startTime: number): ResponseMeta {\n    return {\n      requestId: this.mcpAqlHandler.getCorrelationId() ?? 'unknown',\n      durationMs: parseFloat((performance.now() - startTime).toFixed(2)),\n      timestamp: new Date().toISOString(),\n    };\n  }\n\n  /**\n   * Create a failed operation result\n   */\n  private failure(error: string, startTime: number): OperationResult {\n    return {\n      success: false,\n      error,\n      _meta: this.buildMeta(startTime),\n    };\n  }\n}\n\n/**\n * Get all available operations with their endpoint mappings.\n * This is useful for documentation and help text.\n *\n * @returns Map of operation names to their CRUDE endpoints\n */\nexport function getOperationHelp(): string {\n  return `\n## MCP-AQL Unified Endpoint Operations (CRUDE)\n\n### CREATE Operations (additive, non-destructive)\n- create_element: Create a new element\n- import_element: Import an element from exported data\n- addEntry: Add an entry to a memory element\n- activate_element: Activate an element for use in session\n\n### READ Operations (safe, read-only)\n- list_elements: List elements with filtering and pagination\n- get_element: Retrieve a single element by name\n- get_element_details: Get detailed information about an element\n- search_elements: Full-text search across elements\n- query_elements: Query elements with advanced filters\n- get_active_elements: Get currently active elements\n- validate_element: Validate an element's structure\n- render: Render a template with variables\n- export_element: Export an element to portable format\n- deactivate_element: Deactivate an active element\n\n### UPDATE Operations (modifying)\n- edit_element: Modify an existing element's fields\n\n### DELETE Operations (destructive)\n- delete_element: Permanently delete an element\n- clear: Clear entries from a memory element\n\n### EXECUTE Operations (runtime lifecycle, potentially destructive)\n- execute_agent: Start execution of an agent\n- get_execution_state: Query current execution state\n- record_execution_step: Record execution progress\n- complete_execution: Signal successful completion\n- continue_execution: Resume from saved state\n- abort_execution: Abort a running execution\n`.trim();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UnifiedEndpoint.js","sourceRoot":"","sources":["../../../src/handlers/mcp-aql/UnifiedEndpoint.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * UnifiedEndpoint - Single unified MCP-AQL endpoint handler (Issue #196)\n *\n * This handler provides a single `mcp_aql` endpoint as an alternative to the\n * 4 CRUD endpoints for users who want minimal token footprint (~300-400 tokens\n * vs ~943 tokens for 4 endpoints).\n *\n * ARCHITECTURE:\n * - Single entry point for all MCP-AQL operations\n * - Routes internally to appropriate MCPAQLHandler methods\n * - Uses Gatekeeper (PermissionGuard) for all permission checks\n * - Maintains full security with minimal client-side footprint\n *\n * USE CASES:\n * - Multi-server deployments where token budget is constrained\n * - Clients that prefer simpler tool interfaces\n * - Integration scenarios where 4 endpoints create complexity\n *\n * SECURITY:\n * - All operations pass through PermissionGuard.validate()\n * - Operation routing is determined server-side, not client-side\n * - Full audit logging for all operations\n */\n\nimport { MCPAQLHandler } from './MCPAQLHandler.js';\nimport { getRoute, CRUDEndpoint } from './OperationRouter.js';\nimport { OperationResult, BatchResult, ResponseMeta, isOperationInput, parseOperationInput, describeInvalidInput } from './types.js';\nimport { logger } from '../../utils/logger.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\n\n/**\n * UnifiedEndpoint - Single entry point for all MCP-AQL operations\n *\n * This class wraps MCPAQLHandler to provide a unified endpoint that\n * automatically routes operations to the correct CRUD handler based\n * on the operation name.\n *\n * SECURITY NOTE:\n * Unlike the 4-endpoint mode where the client chooses which endpoint to call,\n * in single-endpoint mode the server determines the appropriate handler\n * based on the operation name. This means:\n * 1. The client cannot bypass security by calling the wrong endpoint\n * 2. All routing is enforced server-side via PermissionGuard\n * 3. The operation-to-endpoint mapping is authoritative\n */\nexport class UnifiedEndpoint {\n  constructor(private readonly mcpAqlHandler: MCPAQLHandler) {}\n\n  /**\n   * Handle any MCP-AQL operation through the unified endpoint.\n   *\n   * This method:\n   * 1. Validates input structure\n   * 2. Determines the correct CRUD endpoint for the operation\n   * 3. Routes to the appropriate handler method\n   * 4. Returns standardized OperationResult or BatchResult\n   *\n   * @param input - Operation input with operation name and params, or BatchRequest\n   * @returns OperationResult or BatchResult with success/failure status\n   */\n  async handle(input: unknown): Promise<OperationResult | BatchResult> {\n    // Issue #301: Capture start time for response timing metadata\n    const startTime = performance.now();\n\n    // Extract operation name for logging (safe access before validation)\n    const operationName = isOperationInput(input) ? input.operation : 'unknown';\n\n    try {\n      // Step 1: Validate and normalize input structure (supports silent JSON fallback)\n      const parsedInput = parseOperationInput(input);\n      if (!parsedInput) {\n        return this.failure(\n          'Invalid input: expected OperationInput with operation name and optional params. ' +\n          describeInvalidInput(input),\n          startTime\n        );\n      }\n\n      const { operation } = parsedInput;\n\n      // Step 2: Determine the correct CRUD endpoint for this operation\n      const route = getRoute(operation);\n      if (!route) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'UPDATE_SECURITY_VIOLATION',\n          severity: 'MEDIUM',\n          source: 'UnifiedEndpoint.handle',\n          details: `Unknown operation: \"${operation}\"`,\n          additionalData: { operation }\n        });\n        return this.failure(\n          `Unknown operation: \"${operation}\". See tool description for available operations.`,\n          startTime\n        );\n      }\n\n      // Step 3: Route to the appropriate handler method\n      // The handler will perform its own PermissionGuard validation\n      // Pass parsedInput to ensure normalized format is used\n      const result = await this.routeToHandler(route.endpoint, parsedInput);\n\n      // Log successful routing\n      SecurityMonitor.logSecurityEvent({\n        type: 'ELEMENT_CREATED',\n        severity: 'LOW',\n        source: 'UnifiedEndpoint.handle',\n        details: `Operation '${operation}' routed to ${route.endpoint} handler`,\n        additionalData: { operation, endpoint: route.endpoint }\n      });\n\n      return result;\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n\n      SecurityMonitor.logSecurityEvent({\n        type: 'UPDATE_SECURITY_VIOLATION',\n        severity: 'MEDIUM',\n        source: 'UnifiedEndpoint.handle',\n        details: `Operation '${operationName}' failed: ${message}`,\n        additionalData: { operation: operationName, error: message }\n      });\n\n      logger.error('UnifiedEndpoint operation failed', {\n        operation: operationName,\n        error: message,\n        stack: error instanceof Error ? error.stack : undefined,\n      });\n\n      return this.failure(message, startTime);\n    }\n  }\n\n  /**\n   * Route input to the appropriate CRUD handler based on endpoint type.\n   *\n   * @param endpoint - The CRUD endpoint determined from operation routing\n   * @param input - The validated operation input\n   * @returns OperationResult or BatchResult from the handler\n   */\n  private async routeToHandler(\n    endpoint: CRUDEndpoint,\n    input: unknown\n  ): Promise<OperationResult | BatchResult> {\n    switch (endpoint) {\n      case 'CREATE':\n        return this.mcpAqlHandler.handleCreate(input);\n      case 'READ':\n        return this.mcpAqlHandler.handleRead(input);\n      case 'UPDATE':\n        return this.mcpAqlHandler.handleUpdate(input);\n      case 'DELETE':\n        return this.mcpAqlHandler.handleDelete(input);\n      case 'EXECUTE':\n        return this.mcpAqlHandler.handleExecute(input);\n      default: {\n        // Exhaustive check - TypeScript will error if a case is missing\n        const _exhaustive: never = endpoint;\n        return _exhaustive;\n      }\n    }\n  }\n\n  /**\n   * Build response metadata with correlation ID and timing.\n   * Issue #301: Request correlation support.\n   */\n  private buildMeta(startTime: number): ResponseMeta {\n    return {\n      requestId: this.mcpAqlHandler.getCorrelationId() ?? 'unknown',\n      durationMs: parseFloat((performance.now() - startTime).toFixed(2)),\n      timestamp: new Date().toISOString(),\n    };\n  }\n\n  /**\n   * Create a failed operation result\n   */\n  private failure(error: string, startTime: number): OperationResult {\n    return {\n      success: false,\n      error,\n      _meta: this.buildMeta(startTime),\n    };\n  }\n}\n\n/**\n * Get all available operations with their endpoint mappings.\n * This is useful for documentation and help text.\n *\n * @returns Map of operation names to their CRUDE endpoints\n */\nexport function getOperationHelp(): string {\n  return `\n## MCP-AQL Unified Endpoint Operations (CRUDE)\n\n### CREATE Operations (additive, non-destructive)\n- create_element: Create a new element\n- import_element: Import an element from exported data\n- addEntry: Add an entry to a memory element\n- activate_element: Activate an element for use in session\n\n### READ Operations (safe, read-only)\n- list_elements: List elements with filtering and pagination\n- get_element: Retrieve a single element by name\n- get_element_details: Get detailed information about an element\n- search_elements: Full-text search across elements\n- query_elements: Query elements with advanced filters\n- get_active_elements: Get currently active elements\n- validate_element: Validate an element's structure\n- render: Render a template with variables\n- export_element: Export an element to portable format\n- deactivate_element: Deactivate an active element\n\n### UPDATE Operations (modifying)\n- edit_element: Modify an existing element's fields\n\n### DELETE Operations (destructive)\n- delete_element: Permanently delete an element\n- clear: Clear entries from a memory element\n\n### EXECUTE Operations (runtime lifecycle, potentially destructive)\n- execute_agent: Start execution of an agent\n- get_execution_state: Query current execution state\n- record_execution_step: Record execution progress\n- complete_execution: Signal successful completion\n- continue_execution: Resume from saved state\n- abort_execution: Abort a running execution\n`.trim();\n}\n"]}

package/dist/handlers/mcp-aql/evaluatePermission.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Permission evaluation for PreToolUse hooks across all AI platforms.
+ *
+ * Provides the `evaluate_permission` MCP-AQL READ operation, enabling
+ * Claude Code, Cursor, Gemini CLI, Windsurf, and Codex to use
+ * DollhouseMCP as their permission evaluation backend via hooks.
+ *
+ * Three-stage evaluation pipeline:
+ * 1. Rate limiting — prevents abuse
+ * 2. Static tool classification — built-in allow/deny rules
+ * 3. Element policy evaluation — active element gatekeeper policies
+ *
+ * Returns platform-specific response formats so each platform's hook
+ * script receives the JSON shape it expects.
+ */
+import type { RateLimiter } from '../../utils/RateLimiter.js';
+import type { ToolClassificationResult, CliToolPolicyResult } from './policies/ToolClassification.js';
+import type { ActiveElement } from './policies/ElementPolicies.js';
+/** Error thrown when permission evaluation fails at a specific stage */
+export declare class PermissionEvaluationError extends Error {
+    readonly stage: 'rate_limit' | 'classification' | 'policy' | 'element_fetch';
+    readonly toolName: string;
+    constructor(message: string, stage: 'rate_limit' | 'classification' | 'policy' | 'element_fetch', toolName: string, cause?: unknown);
+}
+/** Dependencies injected from MCPAQLHandler */
+export interface EvaluatePermissionDeps {
+    permissionPromptLimiter: RateLimiter;
+    classifyTool: (toolName: string, toolInput: Record<string, unknown>) => ToolClassificationResult;
+    evaluateCliToolPolicy: (toolName: string, toolInput: Record<string, unknown>, elements: ActiveElement[]) => CliToolPolicyResult;
+    getActiveElements: () => Promise<ActiveElement[]>;
+}
+/** Known platform identifiers */
+export declare const SUPPORTED_PLATFORMS: string[];
+/**
+ * Format permission evaluation response for platform-specific hook scripts.
+ * Each platform expects a different JSON shape from its hook response.
+ *
+ * Unknown platforms default to claude_code format with a warning log.
+ */
+export declare function formatPermissionResponse(decision: 'allow' | 'deny' | 'ask', platform: string, _input: Record<string, unknown>, reason?: string): Record<string, unknown>;
+/**
+ * Evaluate a CLI permission request for PreToolUse hooks.
+ *
+ * @param params - Tool name, input, and target platform
+ * @param deps - Injected dependencies from MCPAQLHandler
+ * @returns Platform-formatted permission decision
+ */
+export declare function evaluatePermission(params: {
+    tool_name?: unknown;
+    input?: unknown;
+    platform?: unknown;
+}, deps: EvaluatePermissionDeps): Promise<Record<string, unknown>>;
+//# sourceMappingURL=evaluatePermission.d.ts.map

package/dist/handlers/mcp-aql/evaluatePermission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluatePermission.d.ts","sourceRoot":"","sources":["../../../src/handlers/mcp-aql/evaluatePermission.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACtG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,wEAAwE;AACxE,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,SAAgB,KAAK,EAAE,YAAY,GAAG,gBAAgB,GAAG,QAAQ,GAAG,eAAe,CAAC;IACpF,SAAgB,QAAQ,EAAE,MAAM,CAAC;gBAG/B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,YAAY,GAAG,gBAAgB,GAAG,QAAQ,GAAG,eAAe,EACnE,QAAQ,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,OAAO;CAOlB;AAED,+CAA+C;AAC/C,MAAM,WAAW,sBAAsB;IACrC,uBAAuB,EAAE,WAAW,CAAC;IACrC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,wBAAwB,CAAC;IACjG,qBAAqB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,mBAAmB,CAAC;IAChI,iBAAiB,EAAE,MAAM,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CACnD;AA2CD,iCAAiC;AACjC,eAAO,MAAM,mBAAmB,UAAkC,CAAC;AAEnE;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,EAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAczB;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,EACpE,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA8ClC"}

package/dist/handlers/mcp-aql/evaluatePermission.js

@@ -0,0 +1,132 @@
+/**
+ * Permission evaluation for PreToolUse hooks across all AI platforms.
+ *
+ * Provides the `evaluate_permission` MCP-AQL READ operation, enabling
+ * Claude Code, Cursor, Gemini CLI, Windsurf, and Codex to use
+ * DollhouseMCP as their permission evaluation backend via hooks.
+ *
+ * Three-stage evaluation pipeline:
+ * 1. Rate limiting — prevents abuse
+ * 2. Static tool classification — built-in allow/deny rules
+ * 3. Element policy evaluation — active element gatekeeper policies
+ *
+ * Returns platform-specific response formats so each platform's hook
+ * script receives the JSON shape it expects.
+ */
+/** Error thrown when permission evaluation fails at a specific stage */
+export class PermissionEvaluationError extends Error {
+    stage;
+    toolName;
+    constructor(message, stage, toolName, cause) {
+        super(message, cause ? { cause } : undefined);
+        this.name = 'PermissionEvaluationError';
+        this.stage = stage;
+        this.toolName = toolName;
+    }
+}
+/** Optional reason field, only included when reason is provided */
+function withReason(obj, reason, key = 'reason') {
+    return reason ? { ...obj, [key]: reason } : obj;
+}
+/** Gemini: maps 'ask' to 'deny' (no interactive support) */
+function formatGemini(decision, reason) {
+    return withReason({ decision: decision === 'ask' ? 'deny' : decision }, reason);
+}
+/** Cursor: uses 'permission' field instead of 'decision' */
+function formatCursor(decision, reason) {
+    return withReason({ permission: decision }, reason);
+}
+/** Windsurf: uses boolean 'allowed' field */
+function formatWindsurf(decision, reason) {
+    return withReason({ allowed: decision === 'allow' }, reason);
+}
+/** Codex: wraps in hookSpecificOutput, maps 'ask' to 'deny' */
+function formatCodex(decision, reason) {
+    return { hookSpecificOutput: withReason({ permissionDecision: decision === 'ask' ? 'deny' : decision }, reason) };
+}
+/** Claude Code (default): uses 'decision' with 'message' for ask, 'reason' for deny */
+function formatClaudeCode(decision, reason) {
+    if (decision === 'allow')
+        return { decision: 'allow' };
+    if (decision === 'ask')
+        return withReason({ decision: 'ask' }, reason, 'message');
+    return withReason({ decision: 'deny' }, reason);
+}
+/** Platform formatter lookup */
+const platformFormatters = {
+    gemini: formatGemini,
+    cursor: formatCursor,
+    windsurf: formatWindsurf,
+    codex: formatCodex,
+    claude_code: formatClaudeCode,
+};
+/** Known platform identifiers */
+export const SUPPORTED_PLATFORMS = Object.keys(platformFormatters);
+/**
+ * Format permission evaluation response for platform-specific hook scripts.
+ * Each platform expects a different JSON shape from its hook response.
+ *
+ * Unknown platforms default to claude_code format with a warning log.
+ */
+export function formatPermissionResponse(decision, platform, _input, reason) {
+    switch (platform) {
+        case 'gemini': return formatGemini(decision, reason);
+        case 'cursor': return formatCursor(decision, reason);
+        case 'windsurf': return formatWindsurf(decision, reason);
+        case 'codex': return formatCodex(decision, reason);
+        case 'claude_code': return formatClaudeCode(decision, reason);
+        default:
+            // Import lazily to avoid circular dependency at module load time
+            import('../../utils/logger.js').then(({ logger }) => {
+                logger.warn(`[evaluatePermission] Unknown platform "${platform}", defaulting to claude_code format. Supported: ${SUPPORTED_PLATFORMS.join(', ')}`);
+            }).catch(() => { });
+            return formatClaudeCode(decision, reason);
+    }
+}
+/**
+ * Evaluate a CLI permission request for PreToolUse hooks.
+ *
+ * @param params - Tool name, input, and target platform
+ * @param deps - Injected dependencies from MCPAQLHandler
+ * @returns Platform-formatted permission decision
+ */
+export async function evaluatePermission(params, deps) {
+    const toolName = typeof params.tool_name === 'string' ? params.tool_name : '';
+    const inputRaw = params.input;
+    const input = (inputRaw && typeof inputRaw === 'object')
+        ? inputRaw
+        : {};
+    const platform = typeof params.platform === 'string' ? params.platform : 'claude_code';
+    // Rate limit
+    const rateStatus = deps.permissionPromptLimiter.checkLimit();
+    if (!rateStatus.allowed) {
+        return formatPermissionResponse('deny', platform, input, 'Rate limit exceeded');
+    }
+    deps.permissionPromptLimiter.consumeToken();
+    // Stage 1: Static classification
+    const classification = deps.classifyTool(toolName, input);
+    if (classification.behavior === 'allow') {
+        return formatPermissionResponse('allow', platform, input);
+    }
+    if (classification.behavior === 'deny') {
+        return formatPermissionResponse('deny', platform, input, classification.reason);
+    }
+    // Stage 2: Element policy evaluation
+    let elements;
+    try {
+        elements = await deps.getActiveElements();
+    }
+    catch (err) {
+        throw new PermissionEvaluationError(`Failed to fetch active elements for policy evaluation: ${err instanceof Error ? err.message : String(err)}`, 'element_fetch', toolName, err);
+    }
+    const decision = deps.evaluateCliToolPolicy(toolName, input, elements);
+    if (decision.behavior === 'deny') {
+        return formatPermissionResponse('deny', platform, input, decision.message);
+    }
+    if (decision.behavior === 'confirm') {
+        return formatPermissionResponse('ask', platform, input, decision.message || 'Requires confirmation per element policy');
+    }
+    // Default: allow
+    return formatPermissionResponse('allow', platform, input);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluatePermission.js","sourceRoot":"","sources":["../../../src/handlers/mcp-aql/evaluatePermission.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Permission evaluation for PreToolUse hooks across all AI platforms.\n *\n * Provides the `evaluate_permission` MCP-AQL READ operation, enabling\n * Claude Code, Cursor, Gemini CLI, Windsurf, and Codex to use\n * DollhouseMCP as their permission evaluation backend via hooks.\n *\n * Three-stage evaluation pipeline:\n * 1. Rate limiting — prevents abuse\n * 2. Static tool classification — built-in allow/deny rules\n * 3. Element policy evaluation — active element gatekeeper policies\n *\n * Returns platform-specific response formats so each platform's hook\n * script receives the JSON shape it expects.\n */\n\nimport type { RateLimiter } from '../../utils/RateLimiter.js';\nimport type { ToolClassificationResult, CliToolPolicyResult } from './policies/ToolClassification.js';\nimport type { ActiveElement } from './policies/ElementPolicies.js';\n\n/** Error thrown when permission evaluation fails at a specific stage */\nexport class PermissionEvaluationError extends Error {\n  public readonly stage: 'rate_limit' | 'classification' | 'policy' | 'element_fetch';\n  public readonly toolName: string;\n\n  constructor(\n    message: string,\n    stage: 'rate_limit' | 'classification' | 'policy' | 'element_fetch',\n    toolName: string,\n    cause?: unknown,\n  ) {\n    super(message, cause ? { cause } : undefined);\n    this.name = 'PermissionEvaluationError';\n    this.stage = stage;\n    this.toolName = toolName;\n  }\n}\n\n/** Dependencies injected from MCPAQLHandler */\nexport interface EvaluatePermissionDeps {\n  permissionPromptLimiter: RateLimiter;\n  classifyTool: (toolName: string, toolInput: Record<string, unknown>) => ToolClassificationResult;\n  evaluateCliToolPolicy: (toolName: string, toolInput: Record<string, unknown>, elements: ActiveElement[]) => CliToolPolicyResult;\n  getActiveElements: () => Promise<ActiveElement[]>;\n}\n\n/** Optional reason field, only included when reason is provided */\nfunction withReason(obj: Record<string, unknown>, reason?: string, key = 'reason'): Record<string, unknown> {\n  return reason ? { ...obj, [key]: reason } : obj;\n}\n\n/** Gemini: maps 'ask' to 'deny' (no interactive support) */\nfunction formatGemini(decision: string, reason?: string): Record<string, unknown> {\n  return withReason({ decision: decision === 'ask' ? 'deny' : decision }, reason);\n}\n\n/** Cursor: uses 'permission' field instead of 'decision' */\nfunction formatCursor(decision: string, reason?: string): Record<string, unknown> {\n  return withReason({ permission: decision }, reason);\n}\n\n/** Windsurf: uses boolean 'allowed' field */\nfunction formatWindsurf(decision: string, reason?: string): Record<string, unknown> {\n  return withReason({ allowed: decision === 'allow' }, reason);\n}\n\n/** Codex: wraps in hookSpecificOutput, maps 'ask' to 'deny' */\nfunction formatCodex(decision: string, reason?: string): Record<string, unknown> {\n  return { hookSpecificOutput: withReason({ permissionDecision: decision === 'ask' ? 'deny' : decision }, reason) };\n}\n\n/** Claude Code (default): uses 'decision' with 'message' for ask, 'reason' for deny */\nfunction formatClaudeCode(decision: string, reason?: string): Record<string, unknown> {\n  if (decision === 'allow') return { decision: 'allow' };\n  if (decision === 'ask') return withReason({ decision: 'ask' }, reason, 'message');\n  return withReason({ decision: 'deny' }, reason);\n}\n\n/** Platform formatter lookup */\nconst platformFormatters: Record<string, (decision: string, reason?: string) => Record<string, unknown>> = {\n  gemini: formatGemini,\n  cursor: formatCursor,\n  windsurf: formatWindsurf,\n  codex: formatCodex,\n  claude_code: formatClaudeCode,\n};\n\n/** Known platform identifiers */\nexport const SUPPORTED_PLATFORMS = Object.keys(platformFormatters);\n\n/**\n * Format permission evaluation response for platform-specific hook scripts.\n * Each platform expects a different JSON shape from its hook response.\n *\n * Unknown platforms default to claude_code format with a warning log.\n */\nexport function formatPermissionResponse(\n  decision: 'allow' | 'deny' | 'ask',\n  platform: string,\n  _input: Record<string, unknown>,\n  reason?: string,\n): Record<string, unknown> {\n  switch (platform) {\n    case 'gemini': return formatGemini(decision, reason);\n    case 'cursor': return formatCursor(decision, reason);\n    case 'windsurf': return formatWindsurf(decision, reason);\n    case 'codex': return formatCodex(decision, reason);\n    case 'claude_code': return formatClaudeCode(decision, reason);\n    default:\n      // Import lazily to avoid circular dependency at module load time\n      import('../../utils/logger.js').then(({ logger }) => {\n        logger.warn(`[evaluatePermission] Unknown platform \"${platform}\", defaulting to claude_code format. Supported: ${SUPPORTED_PLATFORMS.join(', ')}`);\n      }).catch(() => { /* logger not available */ });\n      return formatClaudeCode(decision, reason);\n  }\n}\n\n/**\n * Evaluate a CLI permission request for PreToolUse hooks.\n *\n * @param params - Tool name, input, and target platform\n * @param deps - Injected dependencies from MCPAQLHandler\n * @returns Platform-formatted permission decision\n */\nexport async function evaluatePermission(\n  params: { tool_name?: unknown; input?: unknown; platform?: unknown },\n  deps: EvaluatePermissionDeps,\n): Promise<Record<string, unknown>> {\n  const toolName = typeof params.tool_name === 'string' ? params.tool_name : '';\n  const inputRaw = params.input;\n  const input = (inputRaw && typeof inputRaw === 'object')\n    ? inputRaw as Record<string, unknown>\n    : {};\n  const platform = typeof params.platform === 'string' ? params.platform : 'claude_code';\n\n  // Rate limit\n  const rateStatus = deps.permissionPromptLimiter.checkLimit();\n  if (!rateStatus.allowed) {\n    return formatPermissionResponse('deny', platform, input, 'Rate limit exceeded');\n  }\n  deps.permissionPromptLimiter.consumeToken();\n\n  // Stage 1: Static classification\n  const classification = deps.classifyTool(toolName, input);\n  if (classification.behavior === 'allow') {\n    return formatPermissionResponse('allow', platform, input);\n  }\n  if (classification.behavior === 'deny') {\n    return formatPermissionResponse('deny', platform, input, classification.reason);\n  }\n\n  // Stage 2: Element policy evaluation\n  let elements: ActiveElement[];\n  try {\n    elements = await deps.getActiveElements();\n  } catch (err) {\n    throw new PermissionEvaluationError(\n      `Failed to fetch active elements for policy evaluation: ${err instanceof Error ? err.message : String(err)}`,\n      'element_fetch', toolName, err,\n    );\n  }\n  const decision = deps.evaluateCliToolPolicy(toolName, input, elements);\n\n  if (decision.behavior === 'deny') {\n    return formatPermissionResponse('deny', platform, input, decision.message);\n  }\n  if (decision.behavior === 'confirm') {\n    return formatPermissionResponse('ask', platform, input,\n      decision.message || 'Requires confirmation per element policy');\n  }\n\n  // Default: allow\n  return formatPermissionResponse('allow', platform, input);\n}\n"]}

package/dist/handlers/mcp-aql/policies/ElementPolicies.d.ts

@@ -81,6 +81,23 @@ export declare function createDecisionFromPolicy(operation: string, result: Elem
  * @throws Error if the policy is malformed
  */
 export declare function parseElementPolicy(metadata: unknown): ElementGatekeeperPolicy | undefined;
+/**
+ * Analyze externalRestrictions patterns for common mistakes and suspicious syntax.
+ *
+ * Returns non-fatal warnings to help LLMs and users write effective patterns.
+ * Does NOT throw — validation errors are handled by {@link validatePatternStrings}.
+ *
+ * Checks performed (Issue #1664):
+ * - Missing tool prefix (pattern doesn't start with ToolName:)
+ * - Overly broad patterns (bare `*` or `ToolName:*`)
+ * - Regex syntax that won't work in glob matching
+ * - Leading/trailing whitespace
+ *
+ * @param patterns - Array of pattern strings to analyze
+ * @param fieldName - Field name for warning messages
+ * @returns Array of warning messages (empty if no issues found)
+ */
+export declare function analyzePatternSyntax(patterns: string[], fieldName: string): string[];
 /**
  * Check if an operation is a gatekeeper infrastructure operation that should
  * skip element policy evaluation in the primary enforcement path.

package/dist/handlers/mcp-aql/policies/ElementPolicies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ElementPolicies.d.ts","sourceRoot":"","sources":["../../../../src/handlers/mcp-aql/policies/ElementPolicies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,eAAe,EACf,KAAK,uBAAuB,EAE5B,KAAK,kBAAkB,EAExB,MAAM,uBAAuB,CAAC;AAM/B;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,uBAAuB,CAAC;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,yBAAyB,CAAC;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,eAAe,EAAE,eAAe,CAAC;IACjC,oDAAoD;IACpD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,mBAAmB,CAAC;IACnE,8DAA8D;IAC9D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,eAAe,CAAA;KAAE,CAAC,CAAC;CAC7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,aAAa,EAAE,EAC/B,iBAAiB,CAAC,EAAE,MAAM,GACzB,mBAAmB,CAgGrB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,mBAAmB,EAC3B,iBAAiB,CAAC,EAAE,MAAM,GACzB,kBAAkB,CA2EpB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,OAAO,GAChB,uBAAuB,GAAG,SAAS,CAgHrC;AAkGD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAErE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GACvF;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAS5C;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GACvF,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAUvC;AAwCD,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,OAAO,EAClB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,uBAAuB,GAAG,SAAS,CAkCrC"}
+{"version":3,"file":"ElementPolicies.d.ts","sourceRoot":"","sources":["../../../../src/handlers/mcp-aql/policies/ElementPolicies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,eAAe,EACf,KAAK,uBAAuB,EAE5B,KAAK,kBAAkB,EAExB,MAAM,uBAAuB,CAAC;AAM/B;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,uBAAuB,CAAC;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,yBAAyB,CAAC;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,eAAe,EAAE,eAAe,CAAC;IACjC,oDAAoD;IACpD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,mBAAmB,CAAC;IACnE,8DAA8D;IAC9D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,eAAe,CAAA;KAAE,CAAC,CAAC;CAC7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,aAAa,EAAE,EAC/B,iBAAiB,CAAC,EAAE,MAAM,GACzB,mBAAmB,CAgGrB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,mBAAmB,EAC3B,iBAAiB,CAAC,EAAE,MAAM,GACzB,kBAAkB,CA2EpB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,OAAO,GAChB,uBAAuB,GAAG,SAAS,CAmHrC;AAgED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAAE,EAClB,SAAS,EAAE,MAAM,GAChB,MAAM,EAAE,CAMV;AA+HD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAErE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GACvF;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAS5C;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GACvF,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAUvC;AAwCD,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,OAAO,EAClB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,uBAAuB,GAAG,SAAS,CAkCrC"}