api-tests-coverage 1.0.0

package/dist/src/intelligence/linkageEngine.js

@@ -0,0 +1,522 @@
+"use strict";
+/**
+ * Coverage Intelligence – Linkage Engine.
+ *
+ * Inspects coverage results and security findings to produce FunctionalFinding
+ * objects and link them to MissingTestRecommendation records.
+ *
+ * The engine is deterministic and does not require MCP to run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRecommendationFromFinding = buildRecommendationFromFinding;
+exports.runLinkageEngine = runLinkageEngine;
+const riskScoring_1 = require("./riskScoring");
+// ─── Simple UUID stub (avoid external dependency) ─────────────────────────────
+let _counter = 0;
+function makeId(prefix) {
+    _counter++;
+    return `${prefix}-${Date.now()}-${_counter}`;
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function normalizeSeverity(raw) {
+    switch (raw.toUpperCase()) {
+        case 'CRITICAL': return 'CRITICAL';
+        case 'HIGH': return 'HIGH';
+        case 'MEDIUM': return 'MEDIUM';
+        default: return 'LOW';
+    }
+}
+function isMoneyPath(path) {
+    if (!path)
+        return false;
+    const lower = path.toLowerCase();
+    return (lower.includes('payment') ||
+        lower.includes('wallet') ||
+        lower.includes('transfer') ||
+        lower.includes('refund') ||
+        lower.includes('debit') ||
+        lower.includes('charge') ||
+        lower.includes('fund') ||
+        lower.includes('payout'));
+}
+function isAuthPath(path) {
+    if (!path)
+        return false;
+    const lower = path.toLowerCase();
+    return (lower.includes('auth') ||
+        lower.includes('login') ||
+        lower.includes('token') ||
+        lower.includes('oauth') ||
+        lower.includes('session') ||
+        lower.includes('password'));
+}
+function frameworkHintsForLanguages(languages) {
+    const hints = [];
+    if (!(languages === null || languages === void 0 ? void 0 : languages.length))
+        return hints;
+    for (const lang of languages) {
+        switch (lang.toLowerCase()) {
+            case 'typescript':
+            case 'javascript':
+                hints.push('jest', 'supertest');
+                break;
+            case 'java':
+                hints.push('junit', 'testng', 'rest-assured', 'spring-mockmvc');
+                break;
+            case 'kotlin':
+                hints.push('kotest', 'junit', 'ktor-test');
+                break;
+            case 'python':
+                hints.push('pytest', 'httpx', 'requests');
+                break;
+            case 'ruby':
+                hints.push('rspec', 'minitest', 'rails-request-specs');
+                break;
+            case 'cucumber':
+                hints.push('cucumber', 'gherkin');
+                break;
+        }
+    }
+    return [...new Set(hints)];
+}
+function recommendationHint(testType, language, framework) {
+    const lang = (language || '').toLowerCase();
+    const fw = (framework || '').toLowerCase();
+    if (lang === 'java' || fw.includes('rest-assured')) {
+        switch (testType) {
+            case 'auth-test': return 'RestAssured authz scenario: .auth().oauth2(token) chain';
+            case 'negative-api-test': return 'RestAssured negative test: expect 4xx status with .statusCode(403)';
+            case 'boundary-test': return 'RestAssured boundary: parameterize with @ParameterizedTest';
+            default: return 'RestAssured test case';
+        }
+    }
+    if (lang === 'python' || fw.includes('pytest')) {
+        switch (testType) {
+            case 'auth-test': return 'pytest fixture: add missing auth header, assert 401/403';
+            case 'negative-api-test': return 'pytest parametrize with invalid inputs, assert HTTP 4xx';
+            case 'boundary-test': return 'pytest @pytest.mark.parametrize with boundary values';
+            default: return 'pytest test function';
+        }
+    }
+    if (lang === 'ruby' || fw.includes('rspec')) {
+        switch (testType) {
+            case 'auth-test': return 'RSpec request spec: without_auth context block';
+            case 'negative-api-test': return 'RSpec: context "with invalid input" do ... expect(response).to have_http_status(422)';
+            case 'boundary-test': return 'RSpec shared_examples with boundary parameter values';
+            default: return 'RSpec request spec';
+        }
+    }
+    if (fw.includes('cucumber') || fw.includes('gherkin')) {
+        return `Scenario: missing coverage – add Gherkin scenario for ${testType}`;
+    }
+    // default JS/TS
+    switch (testType) {
+        case 'auth-test': return 'Jest + supertest: describe("unauthorized") { it("returns 401") }';
+        case 'negative-api-test': return 'Jest + supertest: test invalid inputs → 4xx responses';
+        case 'boundary-test': return 'Jest test.each with boundary value arrays';
+        default: return 'Jest test case';
+    }
+}
+function buildEndpointFindings(details, languages, frameworks) {
+    var _a, _b, _c;
+    const findings = [];
+    if (!Array.isArray(details))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const item of details) {
+        const ep = item.endpoint;
+        const covered = (_a = item.covered) !== null && _a !== void 0 ? _a : false;
+        if (!covered) {
+            findings.push({
+                id: makeId('ff-ep'),
+                source: 'coverage-gap-analysis',
+                category: 'uncovered-endpoint',
+                severity: isMoneyPath(ep === null || ep === void 0 ? void 0 : ep.path) ? 'HIGH' : 'MEDIUM',
+                title: `Uncovered endpoint: ${(_b = ep === null || ep === void 0 ? void 0 : ep.method) !== null && _b !== void 0 ? _b : 'UNKNOWN'} ${(_c = ep === null || ep === void 0 ? void 0 : ep.path) !== null && _c !== void 0 ? _c : '/'}`,
+                description: `Endpoint ${ep === null || ep === void 0 ? void 0 : ep.method} ${ep === null || ep === void 0 ? void 0 : ep.path} has no test coverage.`,
+                endpoint: ep,
+                missingTestTypes: ['positive-api-test', 'negative-api-test'],
+                frameworkHints: fwHints,
+                languageHints: languages,
+                tags: ['endpoint-coverage', 'zero-coverage'],
+            });
+        }
+    }
+    return findings;
+}
+function buildErrorCoverageFindings(details, languages) {
+    var _a, _b, _c;
+    const findings = [];
+    if (!Array.isArray(details))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const item of details) {
+        if (!item.covered && ((_a = item.errorCodes) === null || _a === void 0 ? void 0 : _a.length)) {
+            findings.push({
+                id: makeId('ff-err'),
+                source: 'error-coverage',
+                category: 'error-scenario-gap',
+                severity: 'MEDIUM',
+                title: `Missing error scenario tests for ${(_c = (_b = item.endpoint) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : 'endpoint'}`,
+                description: `Error codes ${item.errorCodes.join(', ')} are documented but have no matching test.`,
+                endpoint: item.endpoint,
+                missingTestTypes: ['negative-api-test'],
+                frameworkHints: fwHints,
+                languageHints: languages,
+                tags: ['error-coverage', 'negative-test'],
+            });
+        }
+    }
+    return findings;
+}
+function buildBusinessCoverageFindings(details, languages) {
+    var _a;
+    const findings = [];
+    if (!Array.isArray(details))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const item of details) {
+        if (!item.covered) {
+            findings.push({
+                id: makeId('ff-biz'),
+                source: 'business-coverage',
+                category: 'missing-business-rule-test',
+                severity: 'MEDIUM',
+                title: `Uncovered business rule: ${(_a = item.name) !== null && _a !== void 0 ? _a : 'unknown'}`,
+                description: `Business rule "${item.name}" has no test coverage.`,
+                relatedRules: item.name ? [item.name] : [],
+                missingTestTypes: ['business-rule-test'],
+                frameworkHints: fwHints,
+                languageHints: languages,
+                tags: ['business-coverage'],
+            });
+        }
+    }
+    return findings;
+}
+function buildIntegrationFlowFindings(details, languages) {
+    var _a, _b;
+    const findings = [];
+    if (!Array.isArray(details))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const flow of details) {
+        if (!flow.steps)
+            continue;
+        for (const step of flow.steps) {
+            if (!step.covered) {
+                findings.push({
+                    id: makeId('ff-flow'),
+                    source: 'integration-flow',
+                    category: 'missing-flow-step-test',
+                    severity: 'MEDIUM',
+                    title: `Uncovered flow step: ${(_a = step.name) !== null && _a !== void 0 ? _a : 'unknown'} in ${(_b = flow.name) !== null && _b !== void 0 ? _b : 'flow'}`,
+                    description: `Integration flow step "${step.name}" has no test coverage.`,
+                    missingTestTypes: ['integration-flow-test'],
+                    frameworkHints: fwHints,
+                    languageHints: languages,
+                    tags: ['integration-flow'],
+                });
+            }
+        }
+    }
+    return findings;
+}
+function buildSecurityCoverageFindings(details, languages) {
+    var _a, _b, _c, _d, _e;
+    const findings = [];
+    if (!Array.isArray(details))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const item of details) {
+        if (!item.covered) {
+            findings.push({
+                id: makeId('ff-sec-cov'),
+                source: 'security-coverage',
+                category: 'missing-auth-test',
+                severity: 'HIGH',
+                title: `Missing auth/security test: ${(_c = (_b = (_a = item.endpoint) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : item.name) !== null && _c !== void 0 ? _c : 'unknown'}`,
+                description: `Security scenario for ${(_e = (_d = item.endpoint) === null || _d === void 0 ? void 0 : _d.path) !== null && _e !== void 0 ? _e : item.name} has no test coverage.`,
+                endpoint: item.endpoint,
+                missingTestTypes: ['auth-test', 'authz-test', 'security-test'],
+                frameworkHints: fwHints,
+                languageHints: languages,
+                tags: ['security-coverage', 'auth-test'],
+            });
+        }
+    }
+    return findings;
+}
+function buildSecurityScanFindings(securityFindings, languages) {
+    var _a, _b;
+    const findings = [];
+    if (!(securityFindings === null || securityFindings === void 0 ? void 0 : securityFindings.length))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const sf of securityFindings) {
+        const severity = normalizeSeverity(sf.severity);
+        findings.push({
+            id: makeId('ff-scan'),
+            source: 'security-scan',
+            category: 'security-finding-unprotected',
+            severity,
+            title: `Scanner finding: ${sf.title}`,
+            description: (_a = sf.description) !== null && _a !== void 0 ? _a : sf.title,
+            endpoint: sf.endpoint,
+            filePaths: sf.filePath ? [sf.filePath] : [],
+            relatedScanners: sf.scanner ? [sf.scanner] : [],
+            missingTestTypes: ['security-test', 'negative-api-test'],
+            frameworkHints: fwHints,
+            languageHints: languages,
+            tags: ['security-scan', (_b = sf.scanner) !== null && _b !== void 0 ? _b : 'scanner', severity.toLowerCase()],
+        });
+    }
+    return findings;
+}
+function buildParameterCoverageFindings(details, languages) {
+    var _a, _b, _c;
+    const findings = [];
+    if (!Array.isArray(details))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const item of details) {
+        if (!item.covered && ((_a = item.missingCategories) === null || _a === void 0 ? void 0 : _a.length)) {
+            const hasBoundary = item.missingCategories.includes('boundary');
+            const hasInvalid = item.missingCategories.includes('invalid');
+            if (hasBoundary) {
+                findings.push({
+                    id: makeId('ff-param-boundary'),
+                    source: 'parameter-coverage',
+                    category: 'missing-boundary-test',
+                    severity: 'MEDIUM',
+                    title: `Missing boundary tests for parameter: ${(_b = item.name) !== null && _b !== void 0 ? _b : 'unknown'}`,
+                    description: `Parameter "${item.name}" is missing boundary value test coverage.`,
+                    endpoint: item.endpoint,
+                    missingTestTypes: ['boundary-test'],
+                    frameworkHints: fwHints,
+                    languageHints: languages,
+                    tags: ['parameter-coverage', 'boundary-test'],
+                });
+            }
+            if (hasInvalid) {
+                findings.push({
+                    id: makeId('ff-param-invalid'),
+                    source: 'parameter-coverage',
+                    category: 'high-risk-parameter-gap',
+                    severity: 'MEDIUM',
+                    title: `Missing invalid-input tests for parameter: ${(_c = item.name) !== null && _c !== void 0 ? _c : 'unknown'}`,
+                    description: `Parameter "${item.name}" is missing invalid input test coverage.`,
+                    endpoint: item.endpoint,
+                    missingTestTypes: ['negative-api-test'],
+                    frameworkHints: fwHints,
+                    languageHints: languages,
+                    tags: ['parameter-coverage', 'negative-test'],
+                });
+            }
+        }
+    }
+    return findings;
+}
+function buildCompatibilityFindings(details, languages) {
+    var _a, _b;
+    const findings = [];
+    if (!Array.isArray(details))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const item of details) {
+        if (item.breakingChange) {
+            findings.push({
+                id: makeId('ff-compat'),
+                source: 'compatibility',
+                category: 'compatibility-risk',
+                severity: 'HIGH',
+                title: `Breaking change risk: ${(_a = item.description) !== null && _a !== void 0 ? _a : 'API contract change'}`,
+                description: (_b = item.description) !== null && _b !== void 0 ? _b : 'A breaking API change was detected with no contract test.',
+                endpoint: item.endpoint,
+                missingTestTypes: ['compatibility-test'],
+                frameworkHints: fwHints,
+                languageHints: languages,
+                tags: ['compatibility', 'breaking-change'],
+            });
+        }
+    }
+    return findings;
+}
+function buildPerfResilienceFindings(details, languages) {
+    var _a, _b, _c, _d, _e, _f;
+    const findings = [];
+    if (!Array.isArray(details))
+        return findings;
+    const fwHints = frameworkHintsForLanguages(languages);
+    for (const item of details) {
+        if (!item.covered) {
+            if (item.hasThreshold) {
+                findings.push({
+                    id: makeId('ff-perf'),
+                    source: 'performance-resilience',
+                    category: 'performance-risk',
+                    severity: 'MEDIUM',
+                    title: `Missing performance test: ${(_c = (_b = (_a = item.endpoint) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : item.name) !== null && _c !== void 0 ? _c : 'unknown'}`,
+                    description: `Endpoint has performance thresholds defined but no performance test exists.`,
+                    endpoint: item.endpoint,
+                    missingTestTypes: ['performance-test'],
+                    frameworkHints: fwHints,
+                    languageHints: languages,
+                    tags: ['performance', 'perf-test'],
+                });
+            }
+            if (item.resilience) {
+                findings.push({
+                    id: makeId('ff-resilience'),
+                    source: 'performance-resilience',
+                    category: 'performance-risk',
+                    severity: 'MEDIUM',
+                    title: `Missing resilience test: ${(_f = (_e = (_d = item.endpoint) === null || _d === void 0 ? void 0 : _d.path) !== null && _e !== void 0 ? _e : item.name) !== null && _f !== void 0 ? _f : 'unknown'}`,
+                    description: `Resilience scenario has no test coverage.`,
+                    endpoint: item.endpoint,
+                    missingTestTypes: ['resilience-test'],
+                    frameworkHints: fwHints,
+                    languageHints: languages,
+                    tags: ['resilience', 'resilience-test'],
+                });
+            }
+        }
+    }
+    return findings;
+}
+// ─── Deduplication ────────────────────────────────────────────────────────────
+function deduplicateFindings(findings) {
+    const seen = new Set();
+    return findings.filter((f) => {
+        var _a, _b, _c, _d;
+        const key = `${f.category}|${(_b = (_a = f.endpoint) === null || _a === void 0 ? void 0 : _a.method) !== null && _b !== void 0 ? _b : ''}|${(_d = (_c = f.endpoint) === null || _c === void 0 ? void 0 : _c.path) !== null && _d !== void 0 ? _d : ''}|${f.title}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+// ─── Recommendation generation ────────────────────────────────────────────────
+function categoryToTestType(category) {
+    switch (category) {
+        case 'uncovered-endpoint': return 'positive-api-test';
+        case 'missing-negative-test': return 'negative-api-test';
+        case 'missing-auth-test': return 'auth-test';
+        case 'missing-boundary-test': return 'boundary-test';
+        case 'missing-business-rule-test': return 'business-rule-test';
+        case 'missing-flow-step-test': return 'integration-flow-test';
+        case 'security-finding-unprotected': return 'security-test';
+        case 'high-risk-parameter-gap': return 'negative-api-test';
+        case 'compatibility-risk': return 'compatibility-test';
+        case 'performance-risk': return 'performance-test';
+        case 'error-scenario-gap': return 'negative-api-test';
+        default: return 'positive-api-test';
+    }
+}
+function buildRecommendationFromFinding(finding, primaryLanguage, primaryFramework) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const testType = categoryToTestType(finding.category);
+    const language = primaryLanguage !== null && primaryLanguage !== void 0 ? primaryLanguage : (_a = finding.languageHints) === null || _a === void 0 ? void 0 : _a[0];
+    const framework = primaryFramework !== null && primaryFramework !== void 0 ? primaryFramework : (_b = finding.frameworkHints) === null || _b === void 0 ? void 0 : _b[0];
+    const hasSecuritySignal = finding.source === 'security-scan' ||
+        finding.category === 'security-finding-unprotected' ||
+        finding.category === 'missing-auth-test';
+    const isMoneyEp = isMoneyPath((_c = finding.endpoint) === null || _c === void 0 ? void 0 : _c.path);
+    const isAuthGap = finding.category === 'missing-auth-test' ||
+        finding.category === 'security-finding-unprotected';
+    const isZeroCoverage = (_e = (_d = finding.tags) === null || _d === void 0 ? void 0 : _d.includes('zero-coverage')) !== null && _e !== void 0 ? _e : false;
+    const score = (0, riskScoring_1.computeRiskScore)({
+        severity: finding.severity,
+        category: finding.category,
+        endpointPath: (_f = finding.endpoint) === null || _f === void 0 ? void 0 : _f.path,
+        hasSecuritySignal,
+        zeroCoverage: isZeroCoverage,
+    });
+    const priority = (0, riskScoring_1.scoreToPriority)(score, {
+        isCriticalSecurityFinding: finding.severity === 'CRITICAL' && hasSecuritySignal,
+        isMoneyMovementEndpoint: isMoneyEp,
+        isAuthGap,
+        isZeroCoverageCriticalFlow: isZeroCoverage &&
+            (0, riskScoring_1.defaultCriticalityWeight)(finding.category, (_g = finding.endpoint) === null || _g === void 0 ? void 0 : _g.path) >= 75,
+    });
+    const hint = recommendationHint(testType, language, framework);
+    return {
+        id: makeId('rec'),
+        priority,
+        title: `Add ${testType.replace(/-/g, ' ')} for: ${finding.title}`,
+        rationale: `${finding.description} ${hint}`,
+        recommendedTestType: testType,
+        endpoint: finding.endpoint,
+        likelyFramework: framework,
+        likelyLanguage: language,
+        linkedFindingIds: [finding.id],
+        riskScore: score,
+        confidence: hasSecuritySignal ? 'high' : isZeroCoverage ? 'high' : 'medium',
+    };
+}
+function deduplicateRecommendations(recs) {
+    var _a, _b, _c, _d, _e;
+    const byKey = new Map();
+    for (const r of recs) {
+        const key = `${r.recommendedTestType}|${(_b = (_a = r.endpoint) === null || _a === void 0 ? void 0 : _a.method) !== null && _b !== void 0 ? _b : ''}|${(_d = (_c = r.endpoint) === null || _c === void 0 ? void 0 : _c.path) !== null && _d !== void 0 ? _d : ''}`;
+        const existing = byKey.get(key);
+        if (!existing || r.riskScore > existing.riskScore) {
+            byKey.set(key, {
+                ...r,
+                linkedFindingIds: [
+                    ...((_e = existing === null || existing === void 0 ? void 0 : existing.linkedFindingIds) !== null && _e !== void 0 ? _e : []),
+                    ...r.linkedFindingIds,
+                ].filter((v, i, a) => a.indexOf(v) === i),
+            });
+        }
+    }
+    return Array.from(byKey.values()).sort((a, b) => b.riskScore - a.riskScore);
+}
+/**
+ * Run the full linkage engine over coverage + security results.
+ * Returns all functional findings and deduplicated recommendations.
+ */
+function runLinkageEngine(input) {
+    var _a, _b;
+    const languages = (_a = input.languages) !== null && _a !== void 0 ? _a : [];
+    const frameworks = (_b = input.frameworks) !== null && _b !== void 0 ? _b : [];
+    const primaryLanguage = languages[0];
+    const primaryFramework = frameworks[0];
+    let allFindings = [];
+    for (const result of input.coverageResults) {
+        switch (result.type) {
+            case 'endpoint':
+                allFindings.push(...buildEndpointFindings(result.details, languages, frameworks));
+                break;
+            case 'error':
+                allFindings.push(...buildErrorCoverageFindings(result.details, languages));
+                break;
+            case 'business':
+                allFindings.push(...buildBusinessCoverageFindings(result.details, languages));
+                break;
+            case 'integration':
+                allFindings.push(...buildIntegrationFlowFindings(result.details, languages));
+                break;
+            case 'security':
+                allFindings.push(...buildSecurityCoverageFindings(result.details, languages));
+                break;
+            case 'parameter':
+                allFindings.push(...buildParameterCoverageFindings(result.details, languages));
+                break;
+            case 'compatibility':
+                allFindings.push(...buildCompatibilityFindings(result.details, languages));
+                break;
+            case 'performance':
+                allFindings.push(...buildPerfResilienceFindings(result.details, languages));
+                break;
+        }
+    }
+    // Add security scanner findings
+    allFindings.push(...buildSecurityScanFindings(input.securityFindings, languages));
+    // Deduplicate
+    const findings = deduplicateFindings(allFindings);
+    // Build recommendations from each finding
+    const rawRecs = findings.map((f) => buildRecommendationFromFinding(f, primaryLanguage, primaryFramework));
+    const recommendations = deduplicateRecommendations(rawRecs);
+    return { findings, recommendations };
+}

package/dist/src/intelligence/markdownReporter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Coverage Intelligence – AI-Friendly Markdown Reporter.
+ *
+ * Generates structured, concise markdown and JSON reports from
+ * IntelligenceReport data.  All outputs are deterministic.
+ */
+import type { IntelligenceReport } from './types';
+export declare function renderCoverageIntelligenceMd(report: IntelligenceReport): string;
+export declare function renderMissingTestsMd(report: IntelligenceReport): string;
+export declare function renderRiskPrioritizationMd(report: IntelligenceReport): string;
+export declare function writeIntelligenceReports(report: IntelligenceReport, outDir: string): void;
+//# sourceMappingURL=markdownReporter.d.ts.map

package/dist/src/intelligence/markdownReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownReporter.d.ts","sourceRoot":"","sources":["../../../src/intelligence/markdownReporter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EACV,kBAAkB,EAMnB,MAAM,SAAS,CAAC;AAwCjB,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAsG/E;AAID,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAyCvE;AAID,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CA8E7E;AAID,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,MAAM,GACb,IAAI,CAsDN"}