api-tests-coverage 1.0.13 → 1.0.14

package/dist/src/pipeline/stages/tia/testLayerClassifier.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Test layer classifier — classifies test files into 7 layers:
+ * unit, component, integration, api, e2e, performance, security.
+ *
+ * Uses multiple signals: directory patterns, naming patterns,
+ * framework annotations, and import analysis.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyTestLayer = classifyTestLayer;
+const path = __importStar(require("path"));
+const CLASSIFICATION_RULES = [
+    {
+        layer: 'e2e',
+        directoryPatterns: [/\be2e\b/i, /\bcypress\b/i, /\bplaywright\b/i, /\bselenium\b/i, /\bfunctional\b/i, /\bacceptance\b/i],
+        fileNamePatterns: [/\.e2e\./i, /\.feature$/i],
+        contentPatterns: [
+            /cy\.\w+/, // Cypress
+            /test\.goto|page\.\w+|playwright/i, // Playwright
+            /driver\.|WebDriver|selenium/i, // Selenium
+            /Given|When|Then|Scenario:/, // Cucumber/Gherkin
+            /browser\.\w+/i, // Browser automation
+        ],
+        priority: 90,
+    },
+    {
+        layer: 'performance',
+        directoryPatterns: [/\bperformance\b/i, /\bperf\b/i, /\bload\b/i, /\bstress\b/i, /\bbenchmark\b/i],
+        fileNamePatterns: [/\.perf\./i, /\.bench\./i, /\.load\./i, /\.k6\./i],
+        contentPatterns: [
+            /import\s.*k6/, // k6
+            /from\s+['"]k6/,
+            /io\.gatling/i, // Gatling
+            /locust|HttpUser|TaskSet/i, // Locust
+            /import\s.*artillery/i, // Artillery
+            /autocannon/i, // Autocannon
+        ],
+        priority: 85,
+    },
+    {
+        layer: 'security',
+        directoryPatterns: [/\bsecurity\b/i, /\bsec-test\b/i, /\bpentest\b/i],
+        fileNamePatterns: [/\.security\./i, /\.sec\./i],
+        contentPatterns: [
+            /@Tag\(["']security["']\)/i, // JUnit @Tag
+            /csrf|xss|sql.?injection|auth.?bypass/i,
+            /ZAP|OWASP|pentest/i,
+        ],
+        priority: 80,
+    },
+    {
+        layer: 'api',
+        directoryPatterns: [/\bapi\b/i, /\bapi[-_]?test\b/i, /\bcontract\b/i],
+        fileNamePatterns: [/\.api\./i, /\.contract\./i],
+        contentPatterns: [
+            /supertest|request\(app\)/i, // Supertest
+            /MockMvc|mockMvc/, // Spring MockMvc
+            /TestRestTemplate|restTemplate/, // Spring RestTemplate
+            /httpx\.AsyncClient/i, // Python httpx
+            /RestAssured|given\(\)\./i, // REST Assured
+            /\.pact\./i, // Pact
+        ],
+        priority: 70,
+    },
+    {
+        layer: 'integration',
+        directoryPatterns: [/\bintegration\b/i, /\bint[-_]?test\b/i],
+        fileNamePatterns: [/\.integration\./i, /\.int\./i, /IT\.java$/],
+        contentPatterns: [
+            /@SpringBootTest/, // Spring Boot integration test
+            /TestRestTemplate/, // Spring REST testing
+            /@Testcontainers/i, // Testcontainers
+            /@DataJpaTest/i, // Spring Data JPA
+            /@WebMvcTest/i, // Spring MVC test
+            /testcontainers/i, // Docker containers
+        ],
+        priority: 60,
+    },
+    {
+        layer: 'component',
+        directoryPatterns: [/\bcomponent\b/i],
+        fileNamePatterns: [/\.component\./i],
+        contentPatterns: [
+            /render\(|screen\./, // React Testing Library
+            /@testing-library/, // Testing Library
+            /shallow\(|mount\(/, // Enzyme
+            /ComponentFixture|TestBed/, // Angular testing
+        ],
+        priority: 50,
+    },
+    {
+        layer: 'unit',
+        directoryPatterns: [/\bunit\b/i],
+        fileNamePatterns: [/\.unit\./i],
+        contentPatterns: [
+        // Unit tests are the default; no specific content patterns needed
+        ],
+        priority: 10,
+    },
+];
+/**
+ * Classify a test file into a layer.
+ *
+ * @param filePath - The test file path
+ * @param content - Optional file content for content-based classification
+ */
+function classifyTestLayer(filePath, content) {
+    const signals = [];
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const basename = path.basename(filePath);
+    // Sort rules by priority (highest first)
+    const sortedRules = [...CLASSIFICATION_RULES].sort((a, b) => b.priority - a.priority);
+    for (const rule of sortedRules) {
+        let matchCount = 0;
+        // Check directory patterns
+        for (const pattern of rule.directoryPatterns) {
+            if (pattern.test(normalizedPath)) {
+                signals.push(`dir:${rule.layer}`);
+                matchCount++;
+                break;
+            }
+        }
+        // Check file name patterns
+        for (const pattern of rule.fileNamePatterns) {
+            if (pattern.test(basename)) {
+                signals.push(`name:${rule.layer}`);
+                matchCount++;
+                break;
+            }
+        }
+        // Check content patterns (if content is available)
+        if (content) {
+            for (const pattern of rule.contentPatterns) {
+                if (pattern.test(content)) {
+                    signals.push(`content:${rule.layer}`);
+                    matchCount++;
+                    break;
+                }
+            }
+        }
+        if (matchCount > 0) {
+            const confidence = matchCount >= 2 ? 'high' : 'medium';
+            return {
+                filePath,
+                layer: rule.layer,
+                confidence,
+                signals,
+            };
+        }
+    }
+    // Default: unit test
+    return {
+        filePath,
+        layer: 'unit',
+        confidence: 'low',
+        signals: ['default:unit'],
+    };
+}

package/dist/src/pipeline/stages/tia/tiaStage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TIA (Test Impact Analysis) stage — Stage 3 of the pipeline.
+ *
+ * Implements:
+ * - Test layer classification (7 layers)
+ * - Mock boundary detection
+ * - Parameterized test expansion
+ * - Test-to-endpoint mapping
+ *
+ * The TIA stage reads the AST stage output from context.stageOutputs
+ * to get semantic models and the knowledge graph.
+ */
+import type { PipelineStage, PipelineContext } from '../../stageInterface';
+import type { TiaOutput } from './types';
+export declare class TiaStage implements PipelineStage<TiaOutput> {
+    readonly name: "tia";
+    readonly optional = false;
+    execute(context: PipelineContext): Promise<TiaOutput>;
+}
+//# sourceMappingURL=tiaStage.d.ts.map

package/dist/src/pipeline/stages/tia/tiaStage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiaStage.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/tiaStage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAWzC,qBAAa,QAAS,YAAW,aAAa,CAAC,SAAS,CAAC;IACvD,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,SAAS;IAEpB,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC;CAmJ5D"}

package/dist/src/pipeline/stages/tia/tiaStage.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * TIA (Test Impact Analysis) stage — Stage 3 of the pipeline.
+ *
+ * Implements:
+ * - Test layer classification (7 layers)
+ * - Mock boundary detection
+ * - Parameterized test expansion
+ * - Test-to-endpoint mapping
+ *
+ * The TIA stage reads the AST stage output from context.stageOutputs
+ * to get semantic models and the knowledge graph.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TiaStage = void 0;
+const testLayerClassifier_1 = require("./testLayerClassifier");
+const mockBoundaryDetector_1 = require("./mockBoundaryDetector");
+const parameterizedTestExpander_1 = require("./parameterizedTestExpander");
+const testEndpointMapper_1 = require("./testEndpointMapper");
+const fileClassifier_1 = require("../../../discovery/fileClassifier");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class TiaStage {
+    constructor() {
+        this.name = 'tia';
+        this.optional = false;
+    }
+    async execute(context) {
+        var _a;
+        const startTime = Date.now();
+        const filesScanned = [];
+        const filesSkipped = [];
+        // Get upstream outputs
+        const astOutput = context.stageOutputs.get('ast');
+        const scaOutput = context.stageOutputs.get('sca');
+        // Collect test files from AST models or discover
+        const testFiles = [];
+        if (astOutput) {
+            for (const [filePath] of astOutput.models) {
+                if ((0, fileClassifier_1.isTestFile)(path.basename(filePath))) {
+                    testFiles.push(filePath);
+                }
+            }
+        }
+        const output = {
+            classifications: [],
+            mockBoundaries: [],
+            parameterizedTests: [],
+            testEndpointMappings: [],
+        };
+        // 1. Classify test layers
+        for (const testFile of testFiles) {
+            let content;
+            try {
+                content = fs.readFileSync(testFile, 'utf-8');
+            }
+            catch {
+                filesSkipped.push({ file: testFile, reason: 'read-error' });
+                continue;
+            }
+            filesScanned.push(testFile);
+            const classification = (0, testLayerClassifier_1.classifyTestLayer)(testFile, content);
+            output.classifications.push(classification);
+            // 2. Detect mock boundaries
+            const language = detectLanguageFromPath(testFile);
+            const boundaries = (0, mockBoundaryDetector_1.detectMockBoundaries)(testFile, content, language);
+            output.mockBoundaries.push(...boundaries);
+            // 3. Expand parameterized tests (RULE-07)
+            const paramTests = (0, parameterizedTestExpander_1.expandParameterizedTests)(testFile, content, language);
+            output.parameterizedTests.push(...paramTests);
+        }
+        // 4. Map tests to endpoints
+        output.testEndpointMappings = (0, testEndpointMapper_1.mapTestsToEndpoints)(context.graph, testFiles);
+        // 5. Populate graph with TIA-discovered nodes
+        // Add mock-boundary nodes
+        for (const boundary of output.mockBoundaries) {
+            const nodeId = `mock-boundary:${boundary.testFilePath}:${boundary.mockedTarget}:${(_a = boundary.line) !== null && _a !== void 0 ? _a : 0}`;
+            if (!context.graph.hasNode(nodeId)) {
+                const node = {
+                    id: nodeId,
+                    type: 'mock-boundary',
+                    label: `Mock: ${boundary.mockedTarget}`,
+                    sourceStage: 'tia',
+                    filePath: boundary.testFilePath,
+                    line: boundary.line,
+                    metadata: {
+                        mockingLibrary: boundary.mockingLibrary,
+                        mockType: boundary.mockType,
+                        mockedTarget: boundary.mockedTarget,
+                    },
+                };
+                context.graph.addNode(node);
+                // Add 'mocks' edge from test file to mock boundary
+                const fileNodeId = `file:${boundary.testFilePath}`;
+                if (context.graph.hasNode(fileNodeId)) {
+                    const edgeId = `${fileNodeId}->mocks->${nodeId}`;
+                    if (!context.graph.hasEdge(edgeId)) {
+                        context.graph.addEdge({
+                            id: edgeId,
+                            type: 'mocks',
+                            sourceNodeId: fileNodeId,
+                            targetNodeId: nodeId,
+                            sourceStage: 'tia',
+                            metadata: { mockType: boundary.mockType },
+                        });
+                    }
+                }
+            }
+        }
+        // Add param-variant nodes (RULE-07: counted as N variants, not 1)
+        for (const paramTest of output.parameterizedTests) {
+            const nodeId = `param-variant:${paramTest.testFilePath}:${paramTest.testName}`;
+            if (!context.graph.hasNode(nodeId)) {
+                const node = {
+                    id: nodeId,
+                    type: 'param-variant',
+                    label: `${paramTest.testName} (${paramTest.variantCount} variants)`,
+                    sourceStage: 'tia',
+                    filePath: paramTest.testFilePath,
+                    line: paramTest.line,
+                    metadata: {
+                        variantCount: paramTest.variantCount,
+                        pattern: paramTest.pattern,
+                    },
+                };
+                context.graph.addNode(node);
+                // Add 'param-expands-to' edge from test file
+                const fileNodeId = `file:${paramTest.testFilePath}`;
+                if (context.graph.hasNode(fileNodeId)) {
+                    const edgeId = `${fileNodeId}->param-expands-to->${nodeId}`;
+                    if (!context.graph.hasEdge(edgeId)) {
+                        context.graph.addEdge({
+                            id: edgeId,
+                            type: 'param-expands-to',
+                            sourceNodeId: fileNodeId,
+                            targetNodeId: nodeId,
+                            sourceStage: 'tia',
+                            metadata: {},
+                        });
+                    }
+                }
+            }
+        }
+        // Record diagnostics (RULE-12)
+        const diagnostics = {
+            stageName: 'tia',
+            filesScanned,
+            filesSkipped,
+            durationMs: Date.now() - startTime,
+            metadata: {
+                testFilesClassified: output.classifications.length,
+                mockBoundariesDetected: output.mockBoundaries.length,
+                parameterizedTestsExpanded: output.parameterizedTests.length,
+                testEndpointMappings: output.testEndpointMappings.length,
+                layerDistribution: countByLayer(output.classifications),
+            },
+        };
+        context.diagnostics.set('tia', diagnostics);
+        context.stageOutputs.set('tia', output);
+        return output;
+    }
+}
+exports.TiaStage = TiaStage;
+function detectLanguageFromPath(filePath) {
+    var _a;
+    const ext = path.extname(filePath).toLowerCase();
+    const map = {
+        '.ts': 'typescript', '.tsx': 'typescript',
+        '.js': 'javascript', '.jsx': 'javascript',
+        '.java': 'java', '.kt': 'kotlin', '.kts': 'kotlin',
+        '.py': 'python', '.rb': 'ruby',
+    };
+    return (_a = map[ext]) !== null && _a !== void 0 ? _a : 'unknown';
+}
+function countByLayer(classifications) {
+    var _a;
+    const counts = {};
+    for (const c of classifications) {
+        counts[c.layer] = ((_a = counts[c.layer]) !== null && _a !== void 0 ? _a : 0) + 1;
+    }
+    return counts;
+}

package/dist/src/pipeline/stages/tia/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * TIA (Test Impact Analysis) stage types.
+ */
+import type { TestLayer, MockType } from '../../types';
+/**
+ * Classification result for a single test file.
+ */
+export interface TestClassification {
+    filePath: string;
+    layer: TestLayer;
+    confidence: 'high' | 'medium' | 'low';
+    signals: string[];
+}
+/**
+ * Detected mock boundary in a test file.
+ */
+export interface DetectedMockBoundary {
+    testFilePath: string;
+    mockingLibrary: string;
+    mockType: MockType;
+    mockedTarget: string;
+    line?: number;
+}
+/**
+ * Result of parameterized test expansion.
+ */
+export interface ExpandedParameterizedTest {
+    testFilePath: string;
+    testName: string;
+    variantCount: number | 'unresolvable';
+    pattern: string;
+    line?: number;
+}
+/**
+ * Mapping from a test file to endpoints it covers.
+ */
+export interface TestEndpointMapping {
+    testFilePath: string;
+    endpointId: string;
+    evidenceType: 'explicit-url' | 'resolved-constant' | 'import-graph' | 'naming-convention' | 'framework-metadata' | 'helper-traversal' | 'page-object';
+    confidence: 'high' | 'medium' | 'low';
+}
+/**
+ * Output of the TIA pipeline stage.
+ */
+export interface TiaOutput {
+    classifications: TestClassification[];
+    mockBoundaries: DetectedMockBoundary[];
+    parameterizedTests: ExpandedParameterizedTest[];
+    testEndpointMappings: TestEndpointMapping[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/pipeline/stages/tia/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAA4B,MAAM,aAAa,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,GAAG,cAAc,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,cAAc,GAAG,mBAAmB,GAAG,cAAc,GAAG,mBAAmB,GAAG,oBAAoB,GAAG,kBAAkB,GAAG,aAAa,CAAC;IACtJ,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,cAAc,EAAE,oBAAoB,EAAE,CAAC;IACvC,kBAAkB,EAAE,yBAAyB,EAAE,CAAC;IAChD,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;CAC7C"}

package/dist/src/pipeline/stages/tia/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * TIA (Test Impact Analysis) stage types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/pipeline/types.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Pipeline types — Coverage Knowledge Graph, nodes, edges, confidence,
+ * conflict, coverage mapping, diagnostics, and output schema.
+ *
+ * These are the canonical types consumed by every stage in the 6-stage
+ * cascaded pipeline (SCA → AST → TIA → IAST → DAST → Graph Merge).
+ */
+export type { ResolutionType } from '../coverage/deep-analysis/types';
+export type { SupportedLanguage, AssertionType, SemanticModel } from '../ast/astTypes';
+/**
+ * Extended confidence level. Adds `verified` to the existing 3-level model.
+ *
+ * - `low`      — Only static AST evidence; no test linkage
+ * - `medium`   — AST + TIA agree; no runtime confirmation
+ * - `high`     — Static + at least one runtime stage (IAST or DAST) confirm
+ * - `verified` — All stages confirm + assertion is traced and confirmed
+ */
+export type PipelineConfidence = 'low' | 'medium' | 'high' | 'verified';
+export type StageName = 'sca' | 'ast' | 'tia' | 'iast' | 'dast' | 'merge';
+export type TestLayer = 'unit' | 'component' | 'integration' | 'api' | 'e2e' | 'performance' | 'security';
+export type CoverageClass = 'unit-covered' | 'component-covered' | 'integration-covered' | 'api-covered' | 'e2e-covered' | 'mock-covered' | 'uncovered';
+export type AssertionSource = 'direct' | 'inherited' | 'fixture' | 'helper' | 'unresolved';
+export type UrlResolution = 'literal' | 'symbolic' | 'unresolved';
+export type ConflictType = 'dast-unreachable' | 'runtime-unconfirmed' | 'stage-disagreement' | 'security-annotation-not-enforced' | 'unhandled-server-error' | 'undeclared-endpoint';
+export type ConflictSeverity = 'info' | 'warning' | 'error';
+export type GraphNodeType = 'endpoint' | 'parameter' | 'controller' | 'service' | 'repository' | 'model' | 'exception-branch' | 'route' | 'file' | 'class' | 'function' | 'test-file' | 'test-suite' | 'test-case' | 'assertion' | 'fixture' | 'helper' | 'base-test-class' | 'mock-boundary' | 'param-variant' | 'conflict' | 'runtime-event' | 'dependency';
+export type GraphEdgeType = 'defines' | 'calls' | 'validates' | 'throws' | 'handles' | 'tests' | 'asserts' | 'extends' | 'imports-helper' | 'mocks' | 'resolves-to' | 'param-expands-to' | 'depends-on' | 'observed-by' | 'executes' | 'conflicts-with';
+export interface GraphNode {
+    id: string;
+    type: GraphNodeType;
+    label: string;
+    sourceStage: StageName;
+    filePath?: string;
+    line?: number;
+    metadata: Record<string, unknown>;
+}
+export interface GraphEdge {
+    id: string;
+    type: GraphEdgeType;
+    sourceNodeId: string;
+    targetNodeId: string;
+    sourceStage: StageName;
+    metadata: Record<string, unknown>;
+}
+export type MockType = 'return-value' | 'exception' | 'spy' | 'partial' | 'timer' | 'env';
+export interface MockBoundary {
+    testId: string;
+    mockedNodeId: string;
+    mockingLibrary: string;
+    mockType: MockType;
+    effect: 'coverage-limited';
+}
+export interface ConflictNode {
+    conflictId: string;
+    nodeId: string;
+    type: ConflictType;
+    stages: StageName[];
+    stageOutputs: Record<string, unknown>;
+    detail: string;
+    suggestedAction: string;
+    severity: ConflictSeverity;
+}
+export type CoverageMappingItemType = 'endpoint' | 'service' | 'repository' | 'error-branch' | 'security-path' | 'validation-rule';
+export interface CoverageMapping {
+    itemId: string;
+    itemType: CoverageMappingItemType;
+    linkedTests: string[];
+    sourceStages: StageName[];
+    confidence: PipelineConfidence;
+    coverageClass: CoverageClass;
+    mockBoundaries: string[];
+    assertionSource: AssertionSource;
+    assertionConfirmed: boolean;
+    dastReachable: boolean | 'not-probed';
+    runtimeConfirmed: boolean;
+    urlResolution: UrlResolution;
+    conflicts: string[];
+    traversalDepth: number;
+}
+export interface SkippedFile {
+    file: string;
+    reason: string;
+}
+export interface StageDiagnostics {
+    stageName: StageName;
+    filesScanned: string[];
+    filesSkipped: SkippedFile[];
+    durationMs: number;
+    metadata: Record<string, unknown>;
+}
+export interface PipelineSummary {
+    totalEndpoints: number;
+    coveredEndpoints: number;
+    verifiedEndpoints: number;
+    uncoveredEndpoints: number;
+    mockLimitedPaths: number;
+    unresolvedAbstractions: number;
+    conflictCount: number;
+    coverageByLayer: Record<TestLayer, number>;
+}
+export interface PipelineSections {
+    endpoints: CoverageMapping[];
+    parameters: CoverageMapping[];
+    integrationFlows: CoverageMapping[];
+    security: CoverageMapping[];
+    errorHandling: CoverageMapping[];
+    performance: CoverageMapping[];
+}
+export interface PipelineOutput {
+    graph: {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    };
+    sections: PipelineSections;
+    diagnostics: Record<StageName, StageDiagnostics>;
+    summary: PipelineSummary;
+}
+export interface ConfidenceEvidence {
+    sourceStages: StageName[];
+    hasIastConfirmation: boolean;
+    hasDastConfirmation: boolean;
+    hasAssertionConfirmation: boolean;
+    hasMockBoundary: boolean;
+    hasPartialResolution: boolean;
+    hasSymbolicUrl: boolean;
+    isStaticOnlyMode: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/pipeline/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/pipeline/types.ts"],"names":[],"mappings":"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"}

package/dist/src/pipeline/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Pipeline types — Coverage Knowledge Graph, nodes, edges, confidence,
+ * conflict, coverage mapping, diagnostics, and output schema.
+ *
+ * These are the canonical types consumed by every stage in the 6-stage
+ * cascaded pipeline (SCA → AST → TIA → IAST → DAST → Graph Merge).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-tests-coverage",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "CLI and library to measure how thoroughly your test suite exercises your API surface area",
   "main": "dist/src/lib/index.js",
   "types": "dist/src/lib/index.d.ts",