@testream/dotnet-reporter 1.1.1 → 1.2.0

package/dist/index.js

@@ -2327,7 +2327,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ensureReportId = exports.mapAttachmentsToTestResults = exports.uploadArtifacts = exports.uploadTestRun = exports.detectCIContext = void 0;
+exports.createTestLocationCollector = exports.enrichReportWithJsTestNameSourceSnippets = exports.resolveSourceSnippetOptions = exports.enrichReportWithSourceSnippets = exports.ensureReportId = exports.mapAttachmentsToTestResults = exports.uploadArtifacts = exports.uploadTestRun = exports.detectCIContext = void 0;
 // CTRF types
 __exportStar(__nccwpck_require__(3827), exports);
 var ci_detection_1 = __nccwpck_require__(2406);
@@ -2337,10 +2337,569 @@ Object.defineProperty(exports, "uploadTestRun", ({ enumerable: true, get: functi
 Object.defineProperty(exports, "uploadArtifacts", ({ enumerable: true, get: function () { return upload_1.uploadArtifacts; } }));
 Object.defineProperty(exports, "mapAttachmentsToTestResults", ({ enumerable: true, get: function () { return upload_1.mapAttachmentsToTestResults; } }));
 Object.defineProperty(exports, "ensureReportId", ({ enumerable: true, get: function () { return upload_1.ensureReportId; } }));
+var source_snippets_1 = __nccwpck_require__(9304);
+Object.defineProperty(exports, "enrichReportWithSourceSnippets", ({ enumerable: true, get: function () { return source_snippets_1.enrichReportWithSourceSnippets; } }));
+Object.defineProperty(exports, "resolveSourceSnippetOptions", ({ enumerable: true, get: function () { return source_snippets_1.resolveSourceSnippetOptions; } }));
+var js_test_name_snippets_1 = __nccwpck_require__(6913);
+Object.defineProperty(exports, "enrichReportWithJsTestNameSourceSnippets", ({ enumerable: true, get: function () { return js_test_name_snippets_1.enrichReportWithJsTestNameSourceSnippets; } }));
+var test_locations_1 = __nccwpck_require__(2293);
+Object.defineProperty(exports, "createTestLocationCollector", ({ enumerable: true, get: function () { return test_locations_1.createTestLocationCollector; } }));
 //# sourceMappingURL=index.js.map
 
 /***/ }),
 
+/***/ 6913:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.enrichReportWithJsTestNameSourceSnippets = enrichReportWithJsTestNameSourceSnippets;
+const promises_1 = __nccwpck_require__(1455);
+const node_path_1 = __importDefault(__nccwpck_require__(6760));
+const source_snippets_1 = __nccwpck_require__(9304);
+const MAX_CANDIDATES = 3;
+// Finds the start of common JS/TS test declarations, then the title is parsed
+// manually so titles can contain non-delimiting quotes like `it("doesn't")`.
+const JS_TEST_DECLARATION_PATTERN = /\b(describe|it|test)(?:\.(only|skip))?\s*\(\s*(['"`])/g;
+async function enrichReportWithJsTestNameSourceSnippets(report, options) {
+    const resolved = (0, source_snippets_1.resolveSourceSnippetOptions)(options);
+    const fileCandidateCache = new Map();
+    await Promise.all(report.results.tests.map(async (test) => {
+        if (test.snippet || !test.filePath) {
+            return;
+        }
+        const filePath = node_path_1.default.resolve(resolved.sourceRoot, test.filePath);
+        if (!isInsideSourceRoot(filePath, resolved.sourceRoot)) {
+            return;
+        }
+        const candidates = await getCachedJsTestCandidates(filePath, fileCandidateCache);
+        if (!candidates) {
+            return;
+        }
+        const matches = rankCandidatesForTest(test, candidates).slice(0, MAX_CANDIDATES);
+        if (matches.length === 0) {
+            return;
+        }
+        test.line ?? (test.line = matches[0].line);
+        test.snippet = formatCandidateSnippet(matches, resolved);
+    }));
+}
+function getCachedJsTestCandidates(filePath, fileCandidateCache) {
+    let cached = fileCandidateCache.get(filePath);
+    if (!cached) {
+        cached = (0, promises_1.readFile)(filePath, 'utf-8')
+            .then((content) => scanJsTestCandidates(content))
+            .catch(() => undefined);
+        fileCandidateCache.set(filePath, cached);
+    }
+    return cached;
+}
+// This scanner intentionally handles the common JS/TS test declaration shapes
+// without adding parser dependencies to every reporter package. Exact runner
+// line metadata still wins; this fallback exists to give AI review bounded
+// source context when the reporter only emitted file path and test name.
+function scanJsTestCandidates(content) {
+    const lineOffsets = buildLineOffsets(content);
+    const blocks = scanJsTestBlocks(content, lineOffsets);
+    const describeBlocks = blocks.filter((block) => block.kind === 'describe');
+    return blocks
+        .filter((block) => block.kind === 'test')
+        .map((block) => {
+        const describeTitles = describeBlocks
+            .filter((describeBlock) => describeBlock.startIndex < block.startIndex && describeBlock.endIndex >= block.endIndex)
+            .sort((left, right) => left.startIndex - right.startIndex)
+            .map((describeBlock) => describeBlock.title);
+        return {
+            title: block.title,
+            describeTitles,
+            fullName: [...describeTitles, block.title].join(' ').trim(),
+            line: block.startLine,
+            snippet: block.snippet,
+        };
+    });
+}
+function scanJsTestBlocks(content, lineOffsets) {
+    const blocks = [];
+    JS_TEST_DECLARATION_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = JS_TEST_DECLARATION_PATTERN.exec(content)) !== null) {
+        if (isCommentedLine(content, match.index)) {
+            continue;
+        }
+        const title = readQuotedTitle(content, match.index + match[0].length, match[3]);
+        if (!title) {
+            continue;
+        }
+        const commaIndex = skipWhitespaceAndFindComma(content, title.endIndex + 1);
+        if (commaIndex == null) {
+            continue;
+        }
+        const kind = match[1] === 'describe' ? 'describe' : 'test';
+        const startIndex = match.index;
+        const openBraceIndex = findCallbackOpenBrace(content, commaIndex + 1);
+        if (openBraceIndex == null) {
+            continue;
+        }
+        const closeBraceIndex = findMatchingBrace(content, openBraceIndex);
+        if (closeBraceIndex == null) {
+            continue;
+        }
+        const endIndex = findSnippetEndIndex(content, closeBraceIndex);
+        const snippet = content.slice(startIndex, endIndex).trim();
+        if (!snippet) {
+            continue;
+        }
+        blocks.push({
+            kind,
+            title: title.value.trim(),
+            startIndex,
+            endIndex,
+            startLine: getLineNumber(lineOffsets, startIndex),
+            snippet,
+        });
+    }
+    return blocks;
+}
+function rankCandidatesForTest(test, candidates) {
+    const normalizedName = normalizeWhitespace(test.name);
+    const suiteChain = normalizeDescribeChain(test.suite);
+    const exactFullNameMatches = candidates.filter((candidate) => normalizeWhitespace(candidate.fullName) === normalizedName);
+    if (exactFullNameMatches.length > 0) {
+        return exactFullNameMatches;
+    }
+    if (suiteChain) {
+        const suiteMatches = candidates.filter((candidate) => normalizeWhitespace(candidate.title) === normalizedName &&
+            normalizeWhitespace(candidate.describeTitles.join(' ')) === suiteChain);
+        if (suiteMatches.length > 0) {
+            return suiteMatches;
+        }
+    }
+    const leafTitleMatches = candidates.filter((candidate) => normalizeWhitespace(candidate.title) === normalizedName);
+    if (leafTitleMatches.length > 0) {
+        return leafTitleMatches;
+    }
+    return candidates.filter((candidate) => {
+        const normalizedTitle = normalizeWhitespace(candidate.title);
+        if (!normalizedName.endsWith(normalizedTitle)) {
+            return false;
+        }
+        const prefix = normalizedName
+            .slice(0, normalizedName.length - normalizedTitle.length)
+            .trim();
+        return prefix.length > 0 && normalizeWhitespace(candidate.describeTitles.join(' ')) === prefix;
+    });
+}
+function formatCandidateSnippet(candidates, options) {
+    const combined = candidates.length === 1
+        ? candidates[0].snippet
+        : candidates
+            .map((candidate, index) => `Candidate ${index + 1} (line ${candidate.line})\n${candidate.snippet}`)
+            .join('\n\n');
+    const boundedLines = combined.split(/\r?\n/).slice(0, options.maxLines).join('\n').trim();
+    if (boundedLines.length <= options.maxChars) {
+        return boundedLines;
+    }
+    return boundedLines.slice(0, options.maxChars);
+}
+function findCallbackOpenBrace(content, fromIndex) {
+    for (let index = fromIndex; index < content.length; index++) {
+        const char = content[index];
+        if (char === "'" || char === '"' || char === '`') {
+            index = skipQuotedString(content, index);
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '/') {
+            index = skipLineComment(content, index + 2);
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '*') {
+            index = skipBlockComment(content, index + 2);
+            continue;
+        }
+        if (content.startsWith('=>', index)) {
+            return findNextBlockBrace(content, index + 2);
+        }
+        if (startsWithWord(content, index, 'function')) {
+            return findNextBlockBrace(content, index + 'function'.length);
+        }
+        if (char === ';') {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function findNextBlockBrace(content, fromIndex) {
+    for (let index = fromIndex; index < content.length; index++) {
+        const char = content[index];
+        if (char === "'" || char === '"' || char === '`') {
+            index = skipQuotedString(content, index);
+            continue;
+        }
+        if (char === '{') {
+            return index;
+        }
+        if (char === '\n' && looksLikeLineTerminator(content, index + 1)) {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function findMatchingBrace(content, openBraceIndex) {
+    let depth = 0;
+    for (let index = openBraceIndex; index < content.length; index++) {
+        const char = content[index];
+        if (char === "'" || char === '"' || char === '`') {
+            index = skipQuotedString(content, index);
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '/') {
+            index = skipLineComment(content, index + 2);
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '*') {
+            index = skipBlockComment(content, index + 2);
+            continue;
+        }
+        if (char === '{') {
+            depth++;
+            continue;
+        }
+        if (char === '}') {
+            depth--;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return undefined;
+}
+function readQuotedTitle(content, startIndex, quote) {
+    let value = '';
+    for (let index = startIndex; index < content.length; index++) {
+        const char = content[index];
+        if (char === '\\') {
+            value += char;
+            if (index + 1 < content.length) {
+                index++;
+                value += content[index];
+            }
+            continue;
+        }
+        if (char === quote) {
+            return { value, endIndex: index };
+        }
+        if (char === '\n' && quote !== '`') {
+            return undefined;
+        }
+        value += char;
+    }
+    return undefined;
+}
+function skipWhitespaceAndFindComma(content, fromIndex) {
+    for (let index = fromIndex; index < content.length; index++) {
+        const char = content[index];
+        if (/\s/.test(char)) {
+            continue;
+        }
+        return char === ',' ? index : undefined;
+    }
+    return undefined;
+}
+function findSnippetEndIndex(content, closeBraceIndex) {
+    let index = closeBraceIndex + 1;
+    while (index < content.length) {
+        const char = content[index];
+        if (char === '\r' || char === '\n') {
+            return index;
+        }
+        index++;
+    }
+    return content.length;
+}
+function skipQuotedString(content, startIndex) {
+    const quote = content[startIndex];
+    for (let index = startIndex + 1; index < content.length; index++) {
+        const char = content[index];
+        if (char === '\\') {
+            index++;
+            continue;
+        }
+        if (char === quote) {
+            return index;
+        }
+    }
+    return content.length - 1;
+}
+function skipLineComment(content, startIndex) {
+    for (let index = startIndex; index < content.length; index++) {
+        if (content[index] === '\n') {
+            return index;
+        }
+    }
+    return content.length - 1;
+}
+function skipBlockComment(content, startIndex) {
+    for (let index = startIndex; index < content.length - 1; index++) {
+        if (content[index] === '*' && content[index + 1] === '/') {
+            return index + 1;
+        }
+    }
+    return content.length - 1;
+}
+function looksLikeLineTerminator(content, index) {
+    for (let cursor = index; cursor < content.length; cursor++) {
+        const char = content[cursor];
+        if (!/\s/.test(char)) {
+            return char !== '.' && char !== '(';
+        }
+    }
+    return false;
+}
+function buildLineOffsets(content) {
+    const offsets = [0];
+    for (let index = 0; index < content.length; index++) {
+        if (content[index] === '\n') {
+            offsets.push(index + 1);
+        }
+    }
+    return offsets;
+}
+function getLineNumber(lineOffsets, index) {
+    let line = 0;
+    for (let i = 0; i < lineOffsets.length; i++) {
+        if (lineOffsets[i] > index) {
+            break;
+        }
+        line = i;
+    }
+    return line + 1;
+}
+function isCommentedLine(content, index) {
+    const lineStart = content.lastIndexOf('\n', index - 1) + 1;
+    const prefix = content.slice(lineStart, index).trimStart();
+    return prefix.startsWith('//') || prefix.startsWith('*');
+}
+function startsWithWord(content, index, word) {
+    if (!content.startsWith(word, index)) {
+        return false;
+    }
+    const before = index === 0 ? '' : content[index - 1];
+    const after = content[index + word.length] ?? '';
+    return !isIdentifierChar(before) && !isIdentifierChar(after);
+}
+function isIdentifierChar(char) {
+    return /[A-Za-z0-9_$]/.test(char);
+}
+function normalizeWhitespace(value) {
+    return (value ?? '').trim().replace(/\s+/g, ' ');
+}
+function normalizeDescribeChain(suite) {
+    if (!suite) {
+        return '';
+    }
+    const segments = suite
+        .split('>')
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    if (segments.length === 0) {
+        return '';
+    }
+    const firstSegmentLooksLikeFile = segments[0].includes('.');
+    const describeSegments = firstSegmentLooksLikeFile ? segments.slice(1) : segments;
+    return normalizeWhitespace(describeSegments.join(' '));
+}
+function isInsideSourceRoot(filePath, sourceRoot) {
+    const relative = node_path_1.default.relative(sourceRoot, filePath);
+    return relative.length > 0 && !relative.startsWith('..') && !node_path_1.default.isAbsolute(relative);
+}
+//# sourceMappingURL=js-test-name-snippets.js.map
+
+/***/ }),
+
+/***/ 9304:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.resolveSourceSnippetOptions = resolveSourceSnippetOptions;
+exports.enrichReportWithSourceSnippets = enrichReportWithSourceSnippets;
+const promises_1 = __nccwpck_require__(1455);
+const node_path_1 = __importDefault(__nccwpck_require__(6760));
+const DEFAULT_MAX_CHARS = 2000;
+const DEFAULT_MAX_LINES = 40;
+function resolveSourceSnippetOptions(options) {
+    return {
+        sourceRoot: node_path_1.default.resolve(options?.sourceRoot ?? process.cwd()),
+        maxChars: normalizePositiveInt(options?.maxChars, DEFAULT_MAX_CHARS),
+        maxLines: normalizePositiveInt(options?.maxLines, DEFAULT_MAX_LINES),
+    };
+}
+// This implementation only extracts JS/TS-style test()/it() blocks.
+// Other languages need reporter-specific snippet logic after that reporter
+// has supplied file/line metadata for the test.
+async function enrichReportWithSourceSnippets(report, options) {
+    const resolved = resolveSourceSnippetOptions(options);
+    const fileContentCache = new Map();
+    await Promise.all(report.results.tests.map(async (test) => {
+        if (test.snippet || !test.filePath || !test.line) {
+            return;
+        }
+        const snippet = await tryExtractSnippet(test, resolved, fileContentCache);
+        if (snippet) {
+            test.snippet = snippet;
+        }
+    }));
+}
+async function tryExtractSnippet(test, options, fileContentCache) {
+    const filePath = node_path_1.default.resolve(options.sourceRoot, test.filePath);
+    if (!isInsideSourceRoot(filePath, options.sourceRoot)) {
+        return undefined;
+    }
+    const content = await getCachedFileContent(filePath, fileContentCache);
+    if (!content) {
+        return undefined;
+    }
+    return extractEnclosingTestBlock(content, test.line, options);
+}
+function getCachedFileContent(filePath, fileContentCache) {
+    let cached = fileContentCache.get(filePath);
+    if (!cached) {
+        cached = (0, promises_1.readFile)(filePath, 'utf-8').catch(() => undefined);
+        fileContentCache.set(filePath, cached);
+    }
+    return cached;
+}
+function extractEnclosingTestBlock(content, lineNumber, options) {
+    const lines = content.split(/\r?\n/);
+    const index = Math.max(0, Math.min(lines.length - 1, lineNumber - 1));
+    const start = findTestStart(lines, index);
+    if (start == null) {
+        return undefined;
+    }
+    const selected = [];
+    let braceBalance = 0;
+    let sawOpeningBrace = false;
+    for (let i = start; i < lines.length && selected.length < options.maxLines; i++) {
+        const line = lines[i];
+        selected.push(line);
+        for (const char of line) {
+            if (char === '{') {
+                braceBalance++;
+                sawOpeningBrace = true;
+            }
+            else if (char === '}') {
+                braceBalance--;
+            }
+        }
+        if (sawOpeningBrace && braceBalance <= 0 && isJsTestBlockTerminator(line)) {
+            break;
+        }
+    }
+    const snippet = selected.join('\n').trim();
+    if (!snippet) {
+        return undefined;
+    }
+    return snippet.length <= options.maxChars
+        ? snippet
+        : snippet.slice(0, options.maxChars);
+}
+function findTestStart(lines, fromIndex) {
+    for (let i = fromIndex; i >= 0; i--) {
+        // Walk upward from runner-provided line metadata until we hit a JS/TS
+        // test/it call, including common modifiers used by Vitest/Playwright.
+        if (/\b(?:test|it)(?:\.(?:only|skip|fixme|slow))?\s*\(/.test(lines[i])) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function isJsTestBlockTerminator(line) {
+    let i = line.length - 1;
+    while (i >= 0 && /\s/.test(line[i])) {
+        i--;
+    }
+    if (i >= 0 && line[i] === ';') {
+        i--;
+    }
+    while (i >= 0 && /\s/.test(line[i])) {
+        i--;
+    }
+    if (i < 1 || line[i] !== ')') {
+        return false;
+    }
+    i--;
+    while (i >= 0 && /\s/.test(line[i])) {
+        i--;
+    }
+    return i >= 0 && line[i] === '}';
+}
+function isInsideSourceRoot(filePath, sourceRoot) {
+    const relative = node_path_1.default.relative(sourceRoot, filePath);
+    return relative.length > 0 && !relative.startsWith('..') && !node_path_1.default.isAbsolute(relative);
+}
+function normalizePositiveInt(value, fallback) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0
+        ? value
+        : fallback;
+}
+//# sourceMappingURL=source-snippets.js.map
+
+/***/ }),
+
+/***/ 2293:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createTestLocationCollector = createTestLocationCollector;
+/**
+ * Generic name-based location mapper for CTRF reports.
+ *
+ * Different reporters can collect test locations in their own format
+ * (Playwright runtime metadata, parsed JUnit XML, etc.) and then feed
+ * this collector to apply file/line metadata in a consistent FIFO way.
+ */
+function createTestLocationCollector() {
+    const locationsByTestName = new Map();
+    return {
+        add(testName, location) {
+            if (!testName || !isValidLocation(location)) {
+                return;
+            }
+            const queue = locationsByTestName.get(testName) ?? [];
+            queue.push(location);
+            locationsByTestName.set(testName, queue);
+        },
+        applyToReport(report) {
+            const queues = new Map([...locationsByTestName.entries()].map(([name, locations]) => [name, [...locations]]));
+            for (const test of report.results.tests) {
+                const queue = queues.get(test.name);
+                const location = queue?.shift();
+                if (!location) {
+                    continue;
+                }
+                test.filePath ?? (test.filePath = location.filePath);
+                test.line ?? (test.line = location.line);
+            }
+        },
+    };
+}
+function isValidLocation(location) {
+    return Boolean(location.filePath) && Number.isInteger(location.line) && location.line > 0;
+}
+//# sourceMappingURL=test-locations.js.map
+
+/***/ }),
+
 /***/ 8969:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
@@ -2352,7 +2911,8 @@ exports.uploadTestRun = uploadTestRun;
 exports.mapAttachmentsToTestResults = mapAttachmentsToTestResults;
 exports.uploadArtifacts = uploadArtifacts;
 const ci_detection_1 = __nccwpck_require__(2406);
-const DEFAULT_API_URL = "https://test-manager-backend.fly.dev";
+const source_snippets_1 = __nccwpck_require__(9304);
+const DEFAULT_API_URL = "https://api.testream.app";
 function ensureReportId(report) {
     if (typeof report.reportId === "string" &&
         report.reportId.trim().length > 0) {
@@ -2448,6 +3008,7 @@ async function uploadTestRun(options) {
     const apiUrl = resolveApiUrl(options.apiUrl);
     const reportId = ensureReportId(report);
     const uploadContext = resolveUploadContext(options);
+    await (0, source_snippets_1.enrichReportWithSourceSnippets)(report);
     // Build type-safe IngestRequest payload
     const ingestPayload = {
         report,
@@ -2588,8 +3149,8 @@ async function uploadArtifacts(options) {
 async function uploadSingleArtifact(options) {
     const { testResultId, attachment, reportId, apiKey, apiUrl } = options;
     // Dynamically import fs for Node.js environments
-    const fs = await Promise.resolve(/* import() */).then(__nccwpck_require__.t.bind(__nccwpck_require__, 1943, 23));
-    const path = await Promise.resolve(/* import() */).then(__nccwpck_require__.t.bind(__nccwpck_require__, 6928, 23));
+    const fs = await Promise.resolve(/* import() */).then(__nccwpck_require__.t.bind(__nccwpck_require__, 1455, 23));
+    const path = await Promise.resolve(/* import() */).then(__nccwpck_require__.t.bind(__nccwpck_require__, 6760, 23));
     const filePath = path.resolve(attachment.path);
     // Check if file exists
     try {
@@ -2672,7 +3233,7 @@ async function uploadWithPresignedUrl(options) {
     }
     const uploadInitResult = (await initResponse.json());
     const uploadHeaders = {
-        ...(uploadInitResult.requiredHeaders ?? {}),
+        ...(uploadInitResult.requiredHeaders),
     };
     if (!hasHeaderIgnoreCase(uploadHeaders, "Content-Type")) {
         uploadHeaders["Content-Type"] = contentType;
@@ -3100,6 +3661,307 @@ async function main() {
 main();
 
 
+/***/ }),
+
+/***/ 148:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createDotnetSourceSnippetResolver = createDotnetSourceSnippetResolver;
+exports.extractDotnetSourceSnippet = extractDotnetSourceSnippet;
+exports.resolveDotnetSourceSnippet = resolveDotnetSourceSnippet;
+const promises_1 = __nccwpck_require__(1455);
+const node_path_1 = __importDefault(__nccwpck_require__(6760));
+const DEFAULT_MAX_CHARS = 2000;
+const DEFAULT_MAX_LINES = 40;
+function createDotnetSourceSnippetResolver() {
+    const cache = {
+        candidateSourceFiles: new Map(),
+        fileContentByPath: new Map(),
+    };
+    return {
+        resolve: (options) => resolveDotnetSourceSnippet(options, cache),
+    };
+}
+async function extractDotnetSourceSnippet(filePath, methodName, lineNumber) {
+    const result = await resolveDotnetSourceSnippet({ filePath, methodName, lineNumber });
+    return result?.snippet;
+}
+async function resolveDotnetSourceSnippet(options, cache) {
+    if (!options.filePath || !options.methodName) {
+        return undefined;
+    }
+    const direct = await tryExtractFromSourceFile(options.filePath, options.methodName, options.lineNumber, cache);
+    if (direct) {
+        return direct;
+    }
+    const candidates = await getCandidateSourceFiles(options.filePath, options.className, cache);
+    for (const candidate of candidates) {
+        const resolved = await tryExtractFromSourceFile(candidate, options.methodName, options.lineNumber, cache);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return undefined;
+}
+async function tryExtractFromSourceFile(filePath, methodName, lineNumber, cache) {
+    if (node_path_1.default.extname(filePath).toLowerCase() !== '.cs') {
+        return undefined;
+    }
+    const resolvedPath = node_path_1.default.resolve(filePath);
+    const content = await getFileContent(resolvedPath, cache);
+    if (!content) {
+        return undefined;
+    }
+    for (const candidateMethodName of getMethodNameCandidates(methodName)) {
+        const extracted = extractCSharpMethodBlock(content, candidateMethodName, lineNumber);
+        if (extracted) {
+            return { filePath: resolvedPath, ...extracted };
+        }
+    }
+    return undefined;
+}
+function getFileContent(filePath, cache) {
+    if (!cache) {
+        return (0, promises_1.readFile)(filePath, 'utf-8').catch(() => undefined);
+    }
+    let cached = cache.fileContentByPath.get(filePath);
+    if (!cached) {
+        cached = (0, promises_1.readFile)(filePath, 'utf-8').catch(() => undefined);
+        cache.fileContentByPath.set(filePath, cached);
+    }
+    return cached;
+}
+function extractCSharpMethodBlock(content, methodName, lineNumber) {
+    const lines = content.split(/\r?\n/);
+    const definitionIndex = findMethodDefinitionNearLine(lines, methodName, lineNumber) ??
+        findMethodDefinition(lines, methodName);
+    if (definitionIndex == null) {
+        return undefined;
+    }
+    const start = includeCSharpAttributes(lines, definitionIndex);
+    const selected = [];
+    let braceBalance = 0;
+    let sawOpeningBrace = false;
+    let isExpressionBodied = false;
+    for (let i = start; i < lines.length && selected.length < DEFAULT_MAX_LINES; i++) {
+        const line = lines[i];
+        selected.push(line);
+        if (!sawOpeningBrace && line.includes('=>')) {
+            isExpressionBodied = true;
+        }
+        for (const char of line) {
+            if (char === '{') {
+                braceBalance++;
+                sawOpeningBrace = true;
+            }
+            else if (char === '}') {
+                braceBalance--;
+            }
+        }
+        if (isExpressionBodied && line.includes(';')) {
+            break;
+        }
+        if (sawOpeningBrace && braceBalance <= 0) {
+            break;
+        }
+    }
+    const snippet = selected.join('\n').trim();
+    if (!snippet) {
+        return undefined;
+    }
+    return {
+        line: start + 1,
+        snippet: snippet.length <= DEFAULT_MAX_CHARS ? snippet : snippet.slice(0, DEFAULT_MAX_CHARS),
+    };
+}
+function findMethodDefinitionNearLine(lines, methodName, lineNumber) {
+    if (!lineNumber) {
+        return undefined;
+    }
+    const startIndex = Math.max(0, Math.min(lines.length - 1, lineNumber - 1));
+    for (let i = startIndex; i >= 0; i--) {
+        if (containsMethodSignatureName(lines[i], methodName)) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function findMethodDefinition(lines, methodName) {
+    for (let i = 0; i < lines.length; i++) {
+        if (containsMethodSignatureName(lines[i], methodName)) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function containsMethodSignatureName(line, methodName) {
+    const nameIndex = line.indexOf(methodName);
+    if (nameIndex < 0) {
+        return false;
+    }
+    const before = nameIndex === 0 ? '' : line[nameIndex - 1];
+    if (before && isIdentifierChar(before)) {
+        return false;
+    }
+    let i = nameIndex + methodName.length;
+    while (i < line.length && /\s/.test(line[i])) {
+        i++;
+    }
+    return line[i] === '(';
+}
+function includeCSharpAttributes(lines, definitionIndex) {
+    let start = definitionIndex;
+    while (start > 0) {
+        const previous = lines[start - 1].trim();
+        if (!previous.startsWith('[') || !previous.endsWith(']')) {
+            break;
+        }
+        start--;
+    }
+    return start;
+}
+function getMethodNameCandidates(methodName) {
+    const trimmed = methodName.trim();
+    const candidates = [trimmed];
+    const invocationIndex = trimmed.indexOf('(');
+    // NUnit can put TestCase argument values in TestMethod/@name, e.g.
+    // Password_MinimumLength_Validation("pass",False). Source matching needs
+    // the underlying C# method identifier.
+    if (invocationIndex > 0) {
+        const sourceMethodName = trimmed.slice(0, invocationIndex).trim();
+        if (sourceMethodName && sourceMethodName !== trimmed) {
+            candidates.push(sourceMethodName);
+        }
+    }
+    return candidates;
+}
+async function findCandidateSourceFiles(storagePath, className) {
+    const sourceRoot = getProjectSourceRootFromStorage(storagePath);
+    if (!sourceRoot) {
+        return [];
+    }
+    const resolvedSourceRoot = await resolveExistingDirectoryCaseInsensitive(sourceRoot);
+    if (!resolvedSourceRoot) {
+        return [];
+    }
+    const files = await listCSharpFiles(resolvedSourceRoot);
+    const classFileName = getClassFileName(className);
+    if (!classFileName) {
+        return files;
+    }
+    // TRX commonly stores passed tests against the compiled DLL. Prefer the class
+    // filename when available, then fall back to every source file for cases where
+    // a project keeps multiple test classes in one file.
+    return [
+        ...files.filter((file) => node_path_1.default.basename(file).toLowerCase() === classFileName),
+        ...files.filter((file) => node_path_1.default.basename(file).toLowerCase() !== classFileName),
+    ];
+}
+function getCandidateSourceFiles(storagePath, className, cache) {
+    if (!cache) {
+        return findCandidateSourceFiles(storagePath, className);
+    }
+    const key = `${node_path_1.default.resolve(storagePath)}\0${className ?? ''}`;
+    let cached = cache.candidateSourceFiles.get(key);
+    if (!cached) {
+        cached = findCandidateSourceFiles(storagePath, className);
+        cache.candidateSourceFiles.set(key, cached);
+    }
+    return cached;
+}
+function getProjectSourceRootFromStorage(storagePath) {
+    const resolved = node_path_1.default.resolve(storagePath);
+    const parts = resolved.split(node_path_1.default.sep);
+    // /Project/bin/Debug/net8.0/Project.dll is the normal TRX storage path for
+    // passed tests, so the source root is the directory before bin/.
+    const binIndex = parts.findIndex((part) => part.toLowerCase() === 'bin');
+    if (binIndex <= 0) {
+        return undefined;
+    }
+    return parts.slice(0, binIndex).join(node_path_1.default.sep) || node_path_1.default.sep;
+}
+async function resolveExistingDirectoryCaseInsensitive(dirPath) {
+    try {
+        await (0, promises_1.readdir)(dirPath, { withFileTypes: true });
+        return dirPath;
+    }
+    catch {
+        // TRX storage paths can lowercase project output paths on Linux
+        // (`mstesttests/bin/...`) while the checked-out source directory is
+        // case-sensitive (`MSTestTests`). Walk each segment case-insensitively so
+        // passed tests can still resolve their project source root.
+    }
+    const resolved = node_path_1.default.resolve(dirPath);
+    const parsed = node_path_1.default.parse(resolved);
+    const relativeParts = node_path_1.default.relative(parsed.root, resolved).split(node_path_1.default.sep).filter(Boolean);
+    let current = parsed.root;
+    for (const part of relativeParts) {
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(current, { withFileTypes: true });
+        }
+        catch {
+            return undefined;
+        }
+        const match = entries.find((entry) => entry.name === part) ??
+            entries.find((entry) => entry.name.toLowerCase() === part.toLowerCase());
+        if (!match) {
+            return undefined;
+        }
+        current = node_path_1.default.join(current, match.name);
+    }
+    try {
+        await (0, promises_1.readdir)(current, { withFileTypes: true });
+        return current;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function listCSharpFiles(root) {
+    const files = [];
+    async function visit(dir) {
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const entryPath = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const lowerName = entry.name.toLowerCase();
+                if (lowerName === 'bin' || lowerName === 'obj') {
+                    continue;
+                }
+                await visit(entryPath);
+                continue;
+            }
+            if (entry.isFile() && node_path_1.default.extname(entry.name).toLowerCase() === '.cs') {
+                files.push(entryPath);
+            }
+        }
+    }
+    await visit(root);
+    return files;
+}
+function getClassFileName(className) {
+    const shortName = className?.split(/[.+]/).filter(Boolean).pop();
+    return shortName ? `${shortName.toLowerCase()}.cs` : undefined;
+}
+function isIdentifierChar(char) {
+    // Prevent matching a method name inside another common C# identifier.
+    return /[A-Za-z0-9_]/.test(char);
+}
+
+
 /***/ }),
 
 /***/ 8914:
@@ -3143,13 +4005,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.parseTrxFile = parseTrxFile;
 exports.parseTrxFiles = parseTrxFiles;
-const fs = __importStar(__nccwpck_require__(1943));
+const fs = __importStar(__nccwpck_require__(1455));
 const fast_xml_parser_1 = __nccwpck_require__(1537);
-const crypto_1 = __nccwpck_require__(6982);
+const node_crypto_1 = __nccwpck_require__(7598);
+const source_snippets_1 = __nccwpck_require__(148);
 const TOOL_NAME = 'dotnet';
 // Use crypto.randomUUID() for secure UUID generation (available in Node.js 15.7.0+)
 function generateUUID() {
-    return (0, crypto_1.randomUUID)();
+    return (0, node_crypto_1.randomUUID)();
 }
 /**
  * Parse TRX duration string (HH:MM:SS.mmmmmmm) to milliseconds
@@ -3162,15 +4025,15 @@ function parseDuration(duration) {
     if (parts.length !== 3)
         return 0;
     const hours = parseInt(parts[0], 10);
-    if (isNaN(hours))
+    if (Number.isNaN(hours))
         return 0;
     const minutes = parseInt(parts[1], 10);
-    if (isNaN(minutes))
+    if (Number.isNaN(minutes))
         return 0;
     // Handle seconds and fractional part (may contain decimal point)
     const secondsParts = parts[2].split('.');
-    const seconds = parseInt(secondsParts[0], 10);
-    if (isNaN(seconds))
+    const seconds = Number.parseInt(secondsParts[0], 10);
+    if (Number.isNaN(seconds))
         return 0;
     const fraction = secondsParts[1] ? parseFloat(`0.${secondsParts[1]}`) * 1000 : 0;
     return hours * 3600000 + minutes * 60000 + seconds * 1000 + Math.round(fraction);
@@ -3182,7 +4045,7 @@ function parseTimestamp(dateStr) {
     if (!dateStr)
         return Date.now();
     const date = new Date(dateStr);
-    return isNaN(date.getTime()) ? Date.now() : date.getTime();
+    return Number.isNaN(date.getTime()) ? Date.now() : date.getTime();
 }
 /**
  * Map TRX outcome to CTRF status
@@ -3210,9 +4073,9 @@ function extractLineNumber(stackTrace) {
     if (!stackTrace)
         return undefined;
     // Match patterns like ":line 79" or ".cs:79"
-    const match = stackTrace.match(/:line (\d+)|\.cs:(\d+)/i);
+    const match = new RegExp(/:line (\d+)|\.cs:(\d+)/i).exec(stackTrace);
     if (match) {
-        return parseInt(match[1] || match[2], 10);
+        return Number.parseInt(match[1] || match[2], 10);
     }
     return undefined;
 }
@@ -3223,7 +4086,7 @@ function extractFilePath(stackTrace) {
     if (!stackTrace)
         return undefined;
     // Match file paths ending in .cs with bounded length to prevent ReDoS
-    const match = stackTrace.match(/([A-Za-z]:\\[^\s:]{1,256}\.cs|\/[^\s:]{1,256}\.cs)/);
+    const match = new RegExp(/([A-Za-z]:\\[^\s:]{1,256}\.cs|\/[^\s:]{1,256}\.cs)/).exec(stackTrace);
     return match ? match[1] : undefined;
 }
 /**
@@ -3257,6 +4120,7 @@ async function parseTrxFile(trxPath) {
     // Parse test results
     const results = testRun.Results?.UnitTestResult || [];
     const tests = [];
+    const sourceSnippetResolver = (0, source_snippets_1.createDotnetSourceSnippetResolver)();
     let passed = 0;
     let failed = 0;
     let skipped = 0;
@@ -3294,6 +4158,15 @@ async function parseTrxFile(trxPath) {
         const stackTrace = result.Output?.ErrorInfo?.StackTrace;
         const stdout = result.Output?.StdOut;
         const stderr = result.Output?.StdErr;
+        const stackTraceFilePath = extractFilePath(stackTrace);
+        const storagePath = testDef?.['@_storage'];
+        const line = extractLineNumber(stackTrace);
+        const sourceSnippet = await sourceSnippetResolver.resolve({
+            filePath: stackTraceFilePath || storagePath,
+            className,
+            methodName: testDef?.TestMethod?.['@_name'],
+            lineNumber: line,
+        });
         const test = {
             name: result['@_testName'],
             status,
@@ -3310,8 +4183,9 @@ async function parseTrxFile(trxPath) {
             stderr: stderr ? [stderr] : [],
             message: errorMessage,
             trace: stackTrace,
-            line: extractLineNumber(stackTrace),
-            filePath: extractFilePath(stackTrace) || testDef?.['@_storage'],
+            line: line ?? sourceSnippet?.line,
+            filePath: sourceSnippet?.filePath ?? stackTraceFilePath ?? storagePath,
+            snippet: sourceSnippet?.snippet,
         };
         tests.push(test);
     }
@@ -3458,27 +4332,27 @@ module.exports = require("child_process");
 
 /***/ }),
 
-/***/ 6982:
+/***/ 9896:
 /***/ ((module) => {
 
 "use strict";
-module.exports = require("crypto");
+module.exports = require("fs");
 
 /***/ }),
 
-/***/ 9896:
+/***/ 1943:
 /***/ ((module) => {
 
 "use strict";
-module.exports = require("fs");
+module.exports = require("fs/promises");
 
 /***/ }),
 
-/***/ 1943:
+/***/ 7598:
 /***/ ((module) => {
 
 "use strict";
-module.exports = require("fs/promises");
+module.exports = require("node:crypto");
 
 /***/ }),