@cleocode/cleo 2026.4.9 → 2026.4.11

package/dist/dispatch/engines/validate-engine.js

@@ -0,0 +1,737 @@
+/**
+ * Validate Engine
+ *
+ * Thin wrapper layer around core validation operations.
+ * Delegates all business logic to src/core/validation/validate-ops.ts.
+ *
+ * @task T4477
+ * @task T4659
+ * @task T4786
+ * @epic T4654
+ */
+import { coreBatchValidate, coreCoherenceCheck, coreComplianceRecord, coreComplianceSummary, coreComplianceViolations, coreTestCoverage, coreTestRun, coreTestStatus, coreValidateManifest, coreValidateOutput, coreValidateProtocol, coreValidateSchema, coreValidateTask, resolveProjectRoot, } from '@cleocode/core/internal';
+import { engineError } from './_error.js';
+/**
+ * validate.schema - JSON Schema validation
+ * @task T4477
+ */
+export function validateSchemaOp(type, data, projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = coreValidateSchema(type, data, root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = message.includes('not found')
+            ? 'E_NOT_FOUND'
+            : message.includes('Unknown schema')
+                ? 'E_INVALID_TYPE'
+                : message.includes('required')
+                    ? 'E_INVALID_INPUT'
+                    : 'E_VALIDATION_ERROR';
+        return engineError(code, message);
+    }
+}
+/**
+ * validate.task - Anti-hallucination task validation
+ * @task T4477
+ */
+export async function validateTask(taskId, projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = await coreValidateTask(taskId, root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = message.includes('not found') ? 'E_NOT_FOUND' : 'E_INVALID_INPUT';
+        return engineError(code, message);
+    }
+}
+/**
+ * validate.protocol - Protocol compliance check
+ * @task T4477
+ */
+export async function validateProtocol(taskId, protocolType, projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = await coreValidateProtocol(taskId, protocolType, root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = message.includes('not found') ? 'E_NOT_FOUND' : 'E_INVALID_INPUT';
+        return engineError(code, message);
+    }
+}
+/**
+ * validate.manifest - Manifest entry validation
+ * @task T4477
+ */
+export function validateManifest(projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = coreValidateManifest(root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return engineError('E_FILE_ERROR', err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * validate.output - Output file validation
+ * @task T4477
+ */
+export function validateOutput(filePath, taskId, projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = coreValidateOutput(filePath, taskId, root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = message.includes('not found') ? 'E_NOT_FOUND' : 'E_INVALID_INPUT';
+        return engineError(code, message);
+    }
+}
+/**
+ * validate.compliance.summary - Aggregated compliance metrics
+ * @task T4477
+ */
+export function validateComplianceSummary(projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = coreComplianceSummary(root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return engineError('E_FILE_ERROR', err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * validate.compliance.violations - List compliance violations
+ * @task T4477
+ */
+export function validateComplianceViolations(limit, projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = coreComplianceViolations(limit, root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return engineError('E_FILE_ERROR', err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * validate.compliance.record - Record compliance check result
+ * @task T4477
+ */
+export function validateComplianceRecord(taskId, result, protocol, violations, projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const data = coreComplianceRecord(taskId, result, protocol, violations, root);
+        return { success: true, data };
+    }
+    catch (err) {
+        return engineError('E_INVALID_INPUT', err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * validate.test.status - Test suite status
+ * @task T4477
+ */
+export function validateTestStatus(projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = coreTestStatus(root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return engineError('E_GENERAL', err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * validate.coherence-check - Cross-validate task graph for consistency
+ * @task T4477
+ */
+export async function validateCoherenceCheck(projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = await coreCoherenceCheck(root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return engineError('E_NOT_INITIALIZED', err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * validate.test.run - Execute test suite via subprocess
+ * @task T4632
+ */
+export function validateTestRun(params, projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = coreTestRun(params, root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return engineError('E_GENERAL', err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * validate.batch-validate - Batch validate all tasks against schema and rules
+ * @task T4632
+ */
+export async function validateBatchValidate(projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = await coreBatchValidate(root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return engineError('E_NOT_FOUND', err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * validate.test.coverage - Coverage metrics
+ * @task T4477
+ */
+export function validateTestCoverage(projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const result = coreTestCoverage(root);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return engineError('E_FILE_ERROR', err instanceof Error ? err.message : String(err));
+    }
+}
+// ============================================================================
+// Protocol Validation Operations (T5327)
+// ============================================================================
+import { checkArchitectureDecisionManifest, checkArtifactPublishManifest, checkConsensusManifest, checkContributionManifest, checkDecompositionManifest, checkImplementationManifest, checkProvenanceManifest, checkReleaseManifest, checkResearchManifest, checkSpecificationManifest, checkTestingManifest, checkValidationManifest, validateArchitectureDecisionTask, validateArtifactPublishTask, validateConsensusTask, validateContributionProtocol as validateContributionTask, validateDecompositionTask, validateImplementationTask, validateProvenanceTask, validateReleaseTask, validateResearchTask, validateSpecificationTask, validateTestingTask, validateValidationTask, } from '@cleocode/core/internal';
+/**
+ * Shared catch handler for protocol validation ops.
+ *
+ * @task T260
+ */
+function protocolCatch(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const code = message.includes('not found')
+        ? 'E_NOT_FOUND'
+        : message.includes('violations')
+            ? 'E_PROTOCOL_VIOLATION'
+            : 'E_VALIDATION_ERROR';
+    return engineError(code, message);
+}
+/**
+ * check.protocol.consensus - Validate consensus protocol compliance
+ * @task T5327
+ */
+export async function validateProtocolConsensus(params, _projectRoot) {
+    try {
+        const { mode, strict, votingMatrixFile } = params;
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateConsensusTask(params.taskId, {
+                strict,
+                votingMatrixFile,
+            });
+            return { success: true, data: result };
+        }
+        else {
+            if (!params.manifestFile) {
+                return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+            }
+            const result = await checkConsensusManifest(params.manifestFile, {
+                strict,
+                votingMatrixFile,
+            });
+            return { success: true, data: result };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = message.includes('not found')
+            ? 'E_NOT_FOUND'
+            : message.includes('violations')
+                ? 'E_PROTOCOL_VIOLATION'
+                : 'E_VALIDATION_ERROR';
+        return engineError(code, message);
+    }
+}
+/**
+ * check.protocol.contribution - Validate contribution protocol compliance
+ * @task T5327
+ */
+export async function validateProtocolContribution(params, _projectRoot) {
+    try {
+        const { mode, strict } = params;
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateContributionTask(params.taskId, { strict });
+            return { success: true, data: result };
+        }
+        else {
+            if (!params.manifestFile) {
+                return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+            }
+            const result = await checkContributionManifest(params.manifestFile, { strict });
+            return { success: true, data: result };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = message.includes('not found')
+            ? 'E_NOT_FOUND'
+            : message.includes('violations')
+                ? 'E_PROTOCOL_VIOLATION'
+                : 'E_VALIDATION_ERROR';
+        return engineError(code, message);
+    }
+}
+/**
+ * check.protocol.decomposition - Validate decomposition protocol compliance
+ * @task T5327
+ */
+export async function validateProtocolDecomposition(params, _projectRoot) {
+    try {
+        const { mode, strict, epicId } = params;
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateDecompositionTask(params.taskId, { strict, epicId });
+            return { success: true, data: result };
+        }
+        else {
+            if (!params.manifestFile) {
+                return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+            }
+            const result = await checkDecompositionManifest(params.manifestFile, { strict, epicId });
+            return { success: true, data: result };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = message.includes('not found')
+            ? 'E_NOT_FOUND'
+            : message.includes('violations')
+                ? 'E_PROTOCOL_VIOLATION'
+                : 'E_VALIDATION_ERROR';
+        return engineError(code, message);
+    }
+}
+/**
+ * check.protocol.implementation - Validate implementation protocol compliance
+ * @task T5327
+ */
+export async function validateProtocolImplementation(params, _projectRoot) {
+    try {
+        const { mode, strict } = params;
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateImplementationTask(params.taskId, { strict });
+            return { success: true, data: result };
+        }
+        else {
+            if (!params.manifestFile) {
+                return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+            }
+            const result = await checkImplementationManifest(params.manifestFile, { strict });
+            return { success: true, data: result };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = message.includes('not found')
+            ? 'E_NOT_FOUND'
+            : message.includes('violations')
+                ? 'E_PROTOCOL_VIOLATION'
+                : 'E_VALIDATION_ERROR';
+        return engineError(code, message);
+    }
+}
+/**
+ * check.protocol.specification - Validate specification protocol compliance
+ * @task T5327
+ */
+export async function validateProtocolSpecification(params, _projectRoot) {
+    try {
+        const { mode, strict, specFile } = params;
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateSpecificationTask(params.taskId, { strict, specFile });
+            return { success: true, data: result };
+        }
+        else {
+            if (!params.manifestFile) {
+                return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+            }
+            const result = await checkSpecificationManifest(params.manifestFile, { strict, specFile });
+            return { success: true, data: result };
+        }
+    }
+    catch (err) {
+        return protocolCatch(err);
+    }
+}
+/**
+ * check.protocol.research - Validate research protocol compliance
+ * @task T260
+ */
+export async function validateProtocolResearch(params, _projectRoot) {
+    try {
+        const { mode, strict, hasCodeChanges } = params;
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateResearchTask(params.taskId, { strict, hasCodeChanges });
+            return { success: true, data: result };
+        }
+        if (!params.manifestFile) {
+            return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+        }
+        const result = await checkResearchManifest(params.manifestFile, { strict, hasCodeChanges });
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return protocolCatch(err);
+    }
+}
+/**
+ * check.protocol.architecture-decision - Validate ADR protocol compliance
+ * @task T260
+ */
+export async function validateProtocolArchitectureDecision(params, _projectRoot) {
+    try {
+        const { mode, strict, adrContent, status, hitlReviewed, downstreamFlagged, persistedInDb } = params;
+        const adrOpts = { strict, adrContent, status, hitlReviewed, downstreamFlagged, persistedInDb };
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateArchitectureDecisionTask(params.taskId, adrOpts);
+            return { success: true, data: result };
+        }
+        if (!params.manifestFile) {
+            return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+        }
+        const result = await checkArchitectureDecisionManifest(params.manifestFile, adrOpts);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return protocolCatch(err);
+    }
+}
+/**
+ * check.protocol.validation - Validate validation-stage protocol compliance
+ * @task T260
+ */
+export async function validateProtocolValidation(params, _projectRoot) {
+    try {
+        const { mode, strict, specMatchConfirmed, testSuitePassed, protocolComplianceChecked } = params;
+        const validationOpts = {
+            strict,
+            specMatchConfirmed,
+            testSuitePassed,
+            protocolComplianceChecked,
+        };
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateValidationTask(params.taskId, validationOpts);
+            return { success: true, data: result };
+        }
+        if (!params.manifestFile) {
+            return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+        }
+        const result = await checkValidationManifest(params.manifestFile, validationOpts);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return protocolCatch(err);
+    }
+}
+/**
+ * check.protocol.testing - Validate testing-stage protocol compliance (IVT loop)
+ * @task T260
+ */
+export async function validateProtocolTesting(params, _projectRoot) {
+    try {
+        const { mode, strict, framework, testsRun, testsPassed, testsFailed, coveragePercent, coverageThreshold, ivtLoopConverged, ivtLoopIterations, } = params;
+        const testingOpts = {
+            strict,
+            framework: framework,
+            testsRun,
+            testsPassed,
+            testsFailed,
+            coveragePercent,
+            coverageThreshold,
+            ivtLoopConverged,
+            ivtLoopIterations,
+        };
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateTestingTask(params.taskId, testingOpts);
+            return { success: true, data: result };
+        }
+        if (!params.manifestFile) {
+            return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+        }
+        const result = await checkTestingManifest(params.manifestFile, testingOpts);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return protocolCatch(err);
+    }
+}
+/**
+ * check.protocol.release - Validate release protocol compliance
+ * @task T260
+ */
+export async function validateProtocolRelease(params, _projectRoot) {
+    try {
+        const { mode, strict, version, hasChangelog } = params;
+        const releaseOpts = { strict, version, hasChangelog };
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateReleaseTask(params.taskId, releaseOpts);
+            return { success: true, data: result };
+        }
+        if (!params.manifestFile) {
+            return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+        }
+        const result = await checkReleaseManifest(params.manifestFile, releaseOpts);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return protocolCatch(err);
+    }
+}
+/**
+ * check.protocol.artifact-publish - Validate artifact-publish protocol compliance
+ * @task T260
+ */
+export async function validateProtocolArtifactPublish(params, _projectRoot) {
+    try {
+        const { mode, strict, artifactType, buildPassed } = params;
+        const artifactOpts = { strict, artifactType, buildPassed };
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateArtifactPublishTask(params.taskId, artifactOpts);
+            return { success: true, data: result };
+        }
+        if (!params.manifestFile) {
+            return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+        }
+        const result = await checkArtifactPublishManifest(params.manifestFile, artifactOpts);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return protocolCatch(err);
+    }
+}
+/**
+ * check.protocol.provenance - Validate provenance protocol compliance
+ * @task T260
+ */
+export async function validateProtocolProvenance(params, _projectRoot) {
+    try {
+        const { mode, strict, hasAttestation, hasSbom } = params;
+        const provenanceOpts = { strict, hasAttestation, hasSbom };
+        if (mode === 'task') {
+            if (!params.taskId) {
+                return engineError('E_INVALID_INPUT', 'taskId is required for task mode');
+            }
+            const result = await validateProvenanceTask(params.taskId, provenanceOpts);
+            return { success: true, data: result };
+        }
+        if (!params.manifestFile) {
+            return engineError('E_INVALID_INPUT', 'manifestFile is required for manifest mode');
+        }
+        const result = await checkProvenanceManifest(params.manifestFile, provenanceOpts);
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return protocolCatch(err);
+    }
+}
+import { getAccessor } from '@cleocode/core/internal';
+const VALID_GATES = [
+    'implemented',
+    'testsPassed',
+    'qaPassed',
+    'cleanupDone',
+    'securityPassed',
+    'documented',
+];
+const DEFAULT_REQUIRED_GATES = [
+    'implemented',
+    'testsPassed',
+    'qaPassed',
+    'securityPassed',
+    'documented',
+];
+function initVerification() {
+    return {
+        passed: false,
+        round: 0,
+        gates: {},
+        lastAgent: null,
+        lastUpdated: null,
+        failureLog: [],
+    };
+}
+function computePassed(verification, requiredGates = DEFAULT_REQUIRED_GATES) {
+    for (const gate of requiredGates) {
+        if (verification.gates[gate] !== true)
+            return false;
+    }
+    return true;
+}
+function getMissingGates(verification, requiredGates = DEFAULT_REQUIRED_GATES) {
+    return requiredGates.filter((g) => verification.gates[g] !== true);
+}
+/** Load required gates from project config, falling back to hardcoded defaults. */
+async function loadRequiredGates(projectRoot) {
+    try {
+        const { loadConfig } = await import('@cleocode/core/internal');
+        const config = await loadConfig(projectRoot);
+        const cfgGates = config.verification?.requiredGates;
+        if (Array.isArray(cfgGates) && cfgGates.length > 0) {
+            return cfgGates.filter((g) => DEFAULT_REQUIRED_GATES.includes(g));
+        }
+    }
+    catch {
+        // fallback
+    }
+    return [...DEFAULT_REQUIRED_GATES];
+}
+/**
+ * check.gate.verify - View or modify verification gates for a task
+ * @task T5327
+ */
+export async function validateGateVerify(params, projectRoot) {
+    try {
+        const root = projectRoot || resolveProjectRoot();
+        const { taskId, gate, value = true, agent, all, reset } = params;
+        // Validate task ID format
+        const idPattern = /^T\d{3,}$/;
+        if (!idPattern.test(taskId)) {
+            return engineError('E_INVALID_INPUT', `Invalid task ID format: ${taskId}`);
+        }
+        const accessor = await getAccessor(root);
+        const task = await accessor.loadSingleTask(taskId);
+        if (!task) {
+            return engineError('E_NOT_FOUND', `Task ${taskId} not found`);
+        }
+        const configGates = await loadRequiredGates(root);
+        // View mode (no modifications)
+        if (!gate && !all && !reset) {
+            const verification = task.verification ?? initVerification();
+            const missing = getMissingGates(verification, configGates);
+            return {
+                success: true,
+                data: {
+                    taskId,
+                    title: task.title,
+                    status: task.status,
+                    type: task.type ?? 'task',
+                    verification,
+                    verificationStatus: verification.passed ? 'passed' : 'pending',
+                    passed: verification.passed,
+                    round: verification.round,
+                    requiredGates: configGates,
+                    missingGates: missing,
+                    action: 'view',
+                },
+            };
+        }
+        // Modification mode
+        let verification = task.verification ?? initVerification();
+        const now = new Date().toISOString();
+        let action = 'view';
+        if (reset) {
+            verification = initVerification();
+            action = 'reset';
+        }
+        else if (all) {
+            for (const g of configGates) {
+                verification.gates[g] = true;
+            }
+            if (agent) {
+                verification.lastAgent = agent;
+            }
+            verification.lastUpdated = now;
+            action = 'set_all';
+        }
+        else if (gate) {
+            if (!VALID_GATES.includes(gate)) {
+                return engineError('E_INVALID_INPUT', `Invalid gate: ${gate}. Valid: ${VALID_GATES.join(', ')}`);
+            }
+            verification.gates[gate] = value;
+            if (agent) {
+                verification.lastAgent = agent;
+            }
+            verification.lastUpdated = now;
+            if (!value) {
+                verification.round++;
+                verification.failureLog.push({
+                    round: verification.round,
+                    agent: agent ?? 'unknown',
+                    reason: `Gate ${gate} set to false`,
+                    timestamp: now,
+                });
+            }
+            action = 'set_gate';
+        }
+        verification.passed = computePassed(verification, configGates);
+        task.verification = verification;
+        task.updatedAt = now;
+        await accessor.upsertSingleTask(task);
+        const missing = getMissingGates(verification, configGates);
+        const result = {
+            taskId,
+            title: task.title,
+            status: task.status,
+            type: task.type ?? 'task',
+            verification,
+            verificationStatus: verification.passed ? 'passed' : 'pending',
+            passed: verification.passed,
+            round: verification.round,
+            requiredGates: configGates,
+            missingGates: missing,
+            action,
+        };
+        if (action === 'set_gate') {
+            result.gateSet = gate;
+        }
+        else if (action === 'set_all') {
+            result.gatesSet = configGates;
+        }
+        return { success: true, data: result };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return engineError('E_GENERAL', message);
+    }
+}
+//# sourceMappingURL=validate-engine.js.map