@testream/dotnet-reporter 1.1.0 → 1.2.0

package/dist/index.js

@@ -2,15 +2,15 @@
 require('./sourcemap-register.js');/******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 537:
+/***/ 1537:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
 const validator = __nccwpck_require__(93);
-const XMLParser = __nccwpck_require__(360);
-const XMLBuilder = __nccwpck_require__(823);
+const XMLParser = __nccwpck_require__(2360);
+const XMLBuilder = __nccwpck_require__(2823);
 
 module.exports = {
   XMLParser: XMLParser,
@@ -20,7 +20,7 @@ module.exports = {
 
 /***/ }),
 
-/***/ 64:
+/***/ 3064:
 /***/ ((module) => {
 
 function getIgnoreAttributesFn(ignoreAttributes) {
@@ -46,7 +46,7 @@ module.exports = getIgnoreAttributesFn
 
 /***/ }),
 
-/***/ 559:
+/***/ 7559:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -132,7 +132,7 @@ exports.nameRegexp = nameRegexp;
 "use strict";
 
 
-const util = __nccwpck_require__(559);
+const util = __nccwpck_require__(7559);
 
 const defaultOptions = {
   allowBooleanAttributes: false, //A tag can have attributes without any value
@@ -559,14 +559,14 @@ function getPositionFromMatch(match) {
 
 /***/ }),
 
-/***/ 823:
+/***/ 2823:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 //parse Empty Node as self closing node
-const buildFromOrderedJs = __nccwpck_require__(57);
-const getIgnoreAttributesFn = __nccwpck_require__(64)
+const buildFromOrderedJs = __nccwpck_require__(1057);
+const getIgnoreAttributesFn = __nccwpck_require__(3064)
 
 const defaultOptions = {
   attributeNamePrefix: '@_',
@@ -853,7 +853,7 @@ module.exports = Builder;
 
 /***/ }),
 
-/***/ 57:
+/***/ 1057:
 /***/ ((module) => {
 
 const EOL = "\n";
@@ -995,10 +995,10 @@ module.exports = toXml;
 
 /***/ }),
 
-/***/ 91:
+/***/ 2091:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-const util = __nccwpck_require__(559);
+const util = __nccwpck_require__(7559);
 
 //TODO: handle comments
 function readDocType(xmlData, i){
@@ -1209,18 +1209,18 @@ exports.defaultOptions = defaultOptions;
 
 /***/ }),
 
-/***/ 629:
+/***/ 2629:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 ///@ts-check
 
-const util = __nccwpck_require__(559);
-const xmlNode = __nccwpck_require__(79);
-const readDocType = __nccwpck_require__(91);
-const toNumber = __nccwpck_require__(236);
-const getIgnoreAttributesFn = __nccwpck_require__(64)
+const util = __nccwpck_require__(7559);
+const xmlNode = __nccwpck_require__(7079);
+const readDocType = __nccwpck_require__(2091);
+const toNumber = __nccwpck_require__(6236);
+const getIgnoreAttributesFn = __nccwpck_require__(3064)
 
 // const regx =
 //   '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)'
@@ -1823,12 +1823,12 @@ module.exports = OrderedObjParser;
 
 /***/ }),
 
-/***/ 360:
+/***/ 2360:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const { buildOptions} = __nccwpck_require__(901);
-const OrderedObjParser = __nccwpck_require__(629);
-const { prettify} = __nccwpck_require__(318);
+const OrderedObjParser = __nccwpck_require__(2629);
+const { prettify} = __nccwpck_require__(5318);
 const validator = __nccwpck_require__(93);
 
 class XMLParser{
@@ -1887,7 +1887,7 @@ module.exports = XMLParser;
 
 /***/ }),
 
-/***/ 318:
+/***/ 5318:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -2008,7 +2008,7 @@ exports.prettify = prettify;
 
 /***/ }),
 
-/***/ 79:
+/***/ 7079:
 /***/ ((module) => {
 
 "use strict";
@@ -2040,7 +2040,7 @@ module.exports = XmlNode;
 
 /***/ }),
 
-/***/ 236:
+/***/ 6236:
 /***/ ((module) => {
 
 const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
@@ -2157,7 +2157,7 @@ module.exports = toNumber;
 
 /***/ }),
 
-/***/ 406:
+/***/ 2406:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -2296,7 +2296,7 @@ function detectCIContext() {
 
 /***/ }),
 
-/***/ 827:
+/***/ 3827:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -2307,7 +2307,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 
 /***/ }),
 
-/***/ 322:
+/***/ 7322:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
@@ -2327,21 +2327,580 @@ 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__(827), exports);
-var ci_detection_1 = __nccwpck_require__(406);
+__exportStar(__nccwpck_require__(3827), exports);
+var ci_detection_1 = __nccwpck_require__(2406);
 Object.defineProperty(exports, "detectCIContext", ({ enumerable: true, get: function () { return ci_detection_1.detectCIContext; } }));
-var upload_1 = __nccwpck_require__(969);
+var upload_1 = __nccwpck_require__(8969);
 Object.defineProperty(exports, "uploadTestRun", ({ enumerable: true, get: function () { return upload_1.uploadTestRun; } }));
 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
 
 /***/ }),
 
-/***/ 969:
+/***/ 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__) => {
 
 "use strict";
@@ -2351,10 +2910,12 @@ exports.ensureReportId = ensureReportId;
 exports.uploadTestRun = uploadTestRun;
 exports.mapAttachmentsToTestResults = mapAttachmentsToTestResults;
 exports.uploadArtifacts = uploadArtifacts;
-const ci_detection_1 = __nccwpck_require__(406);
-const DEFAULT_API_URL = 'https://test-manager-backend.fly.dev';
+const ci_detection_1 = __nccwpck_require__(2406);
+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) {
+    if (typeof report.reportId === "string" &&
+        report.reportId.trim().length > 0) {
         return report.reportId;
     }
     const reportId = crypto.randomUUID();
@@ -2373,7 +2934,7 @@ function resolveApiUrl(explicitApiUrl) {
     return DEFAULT_API_URL;
 }
 function getEnvApiUrl() {
-    if (typeof process === 'undefined' || !process?.env) {
+    if (typeof process === "undefined" || !process?.env) {
         return undefined;
     }
     return normalizeApiUrl(process.env.TESTREAM_API_URL);
@@ -2386,20 +2947,25 @@ function normalizeApiUrl(value) {
     if (!trimmed) {
         return undefined;
     }
-    return trimmed.replace(/\/+$/, '');
+    // Use while loop instead of regex for better performance and clarity
+    let result = trimmed;
+    while (result.endsWith("/")) {
+        result = result.slice(0, -1);
+    }
+    return result;
 }
 function isReportAlreadyExistsConflict(error) {
-    return error.errorCode === 'report_already_exists';
+    return error.errorCode === "report_already_exists";
 }
 function formatUploadError(error) {
-    const detail = error.detail || error.title || error.rawBody || 'Unknown error';
-    const codeLabel = error.errorCode ? `, code=${error.errorCode}` : '';
+    const detail = error.detail || error.title || error.rawBody || "Unknown error";
+    const codeLabel = error.errorCode ? `, code=${error.errorCode}` : "";
     return `Upload failed (HTTP ${error.statusCode}${codeLabel}): ${detail}`;
 }
 async function parseHttpError(response) {
     const rawBody = await response.text();
-    const contentType = response.headers.get('content-type') || '';
-    if (contentType.toLowerCase().includes('json') && rawBody.trim().length > 0) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.toLowerCase().includes("json") && rawBody.trim().length > 0) {
         try {
             const parsed = JSON.parse(rawBody);
             return {
@@ -2442,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,
@@ -2449,14 +3016,14 @@ async function uploadTestRun(options) {
         ...uploadContext,
     };
     // Professional logging
-    console.log('Uploading test results...');
+    console.log("Uploading test results...");
     let response;
     try {
         response = await fetch(`${apiUrl}/api/v1/ingest`, {
-            method: 'POST',
+            method: "POST",
             headers: {
-                'X-API-KEY': apiKey,
-                'Content-Type': 'application/json',
+                "X-API-KEY": apiKey,
+                "Content-Type": "application/json",
             },
             body: JSON.stringify(ingestPayload),
         });
@@ -2474,7 +3041,7 @@ async function uploadTestRun(options) {
     if (!response.ok) {
         const parsedError = await parseHttpError(response);
         if (response.status === 409 && isReportAlreadyExistsConflict(parsedError)) {
-            console.warn('Report already exists (workflow may have been re-run)');
+            console.warn("Report already exists (workflow may have been re-run)");
             return {
                 success: true,
                 reportId,
@@ -2582,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__, 943, 23));
-    const path = await Promise.resolve(/* import() */).then(__nccwpck_require__.t.bind(__nccwpck_require__, 928, 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 {
@@ -2597,7 +3164,7 @@ async function uploadSingleArtifact(options) {
     let fileBuffer;
     let sizeBytes;
     const fileName = path.basename(filePath);
-    const contentType = attachment.contentType || 'application/octet-stream';
+    const contentType = attachment.contentType || "application/octet-stream";
     try {
         fileBuffer = await fs.readFile(filePath);
         sizeBytes = fileBuffer.byteLength;
@@ -2637,7 +3204,7 @@ async function uploadSingleArtifact(options) {
 }
 class LegacyUploadRequiredError extends Error {
     constructor() {
-        super('Legacy upload endpoint required');
+        super("Legacy upload endpoint required");
     }
 }
 async function uploadWithPresignedUrl(options) {
@@ -2650,10 +3217,10 @@ async function uploadWithPresignedUrl(options) {
         sizeBytes,
     };
     const initResponse = await fetch(`${apiUrl}/api/v1/artifacts/${reportId}/upload-url`, {
-        method: 'POST',
+        method: "POST",
         headers: {
-            'X-API-KEY': apiKey,
-            'Content-Type': 'application/json',
+            "X-API-KEY": apiKey,
+            "Content-Type": "application/json",
         },
         body: JSON.stringify(initPayload),
     });
@@ -2665,12 +3232,14 @@ async function uploadWithPresignedUrl(options) {
         throw new Error(`Failed to create direct upload URL (HTTP ${initResponse.status}): ${errorText}`);
     }
     const uploadInitResult = (await initResponse.json());
-    const uploadHeaders = { ...(uploadInitResult.requiredHeaders ?? {}) };
-    if (!hasHeaderIgnoreCase(uploadHeaders, 'Content-Type')) {
-        uploadHeaders['Content-Type'] = contentType;
+    const uploadHeaders = {
+        ...(uploadInitResult.requiredHeaders),
+    };
+    if (!hasHeaderIgnoreCase(uploadHeaders, "Content-Type")) {
+        uploadHeaders["Content-Type"] = contentType;
     }
     const directUploadResponse = await fetch(uploadInitResult.uploadUrl, {
-        method: 'PUT',
+        method: "PUT",
         headers: uploadHeaders,
         body: fileBuffer,
     });
@@ -2687,10 +3256,10 @@ async function uploadWithPresignedUrl(options) {
         storageKey: uploadInitResult.storageKey,
     };
     const completeResponse = await fetch(`${apiUrl}/api/v1/artifacts/${reportId}/complete`, {
-        method: 'POST',
+        method: "POST",
         headers: {
-            'X-API-KEY': apiKey,
-            'Content-Type': 'application/json',
+            "X-API-KEY": apiKey,
+            "Content-Type": "application/json",
         },
         body: JSON.stringify(completePayload),
     });
@@ -2701,16 +3270,16 @@ async function uploadWithPresignedUrl(options) {
     return true;
 }
 async function uploadWithLegacyEndpoint(options) {
-    const { testResultId, attachmentName, reportId, apiKey, apiUrl, fileName, contentType, fileBuffer } = options;
+    const { testResultId, attachmentName, reportId, apiKey, apiUrl, fileName, contentType, fileBuffer, } = options;
     const blob = new Blob([new Uint8Array(fileBuffer)], { type: contentType });
     const formData = new FormData();
-    formData.append('testResultId', testResultId);
-    formData.append('ctrfAttachmentName', attachmentName);
-    formData.append('file', blob, fileName);
+    formData.append("testResultId", testResultId);
+    formData.append("ctrfAttachmentName", attachmentName);
+    formData.append("file", blob, fileName);
     const response = await fetch(`${apiUrl}/api/v1/artifacts/${reportId}`, {
-        method: 'POST',
+        method: "POST",
         headers: {
-            'X-API-KEY': apiKey,
+            "X-API-KEY": apiKey,
         },
         body: formData,
     });
@@ -2731,7 +3300,7 @@ function hasHeaderIgnoreCase(headers, headerName) {
 
 /***/ }),
 
-/***/ 328:
+/***/ 4328:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
@@ -2771,14 +3340,14 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const glob_1 = __nccwpck_require__(447);
-const path = __importStar(__nccwpck_require__(928));
-const fs = __importStar(__nccwpck_require__(943));
+const path = __importStar(__nccwpck_require__(6928));
+const fs = __importStar(__nccwpck_require__(1943));
 const os = __importStar(__nccwpck_require__(857));
-const child_process_1 = __nccwpck_require__(317);
-const trx_parser_1 = __nccwpck_require__(914);
-const uploader_1 = __nccwpck_require__(10);
+const child_process_1 = __nccwpck_require__(5317);
+const trx_parser_1 = __nccwpck_require__(8914);
+const uploader_1 = __nccwpck_require__(8010);
 function printUsage() {
-    console.log(`
+    console.log(String.raw `
 @testream/dotnet-reporter - Run .NET tests and upload results to Testream
 
 Usage:
@@ -2823,7 +3392,7 @@ Examples:
   npx @testream/dotnet-reporter -k your-api-key --project ./MyTests
 
   # With environment metadata
-  npx @testream/dotnet-reporter -k your-api-key \\
+  npx @testream/dotnet-reporter -k your-api-key \
     --test-environment staging --app-name MyApp --app-version 1.0.0
 
   # Pass additional arguments to dotnet test
@@ -2960,15 +3529,15 @@ async function runDotnetTest(projectPath, additionalArgs = []) {
     const logger = console;
     // Create temp directory for TRX output
     const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dotnet-reporter-'));
-    const trxFileName = `results-${Date.now()}.trx`;
     // Build dotnet test command
     const args = ['test'];
     if (projectPath) {
         args.push(projectPath);
     }
-    // Add TRX logger
-    args.push('--logger', `trx;LogFileName=${trxFileName}`);
-    args.push('--results-directory', tempDir);
+    // Add TRX logger without a fixed filename so each test project gets a unique
+    // TRX file. Specifying LogFileName causes all projects in a solution to write
+    // to the same file, with later projects overwriting earlier ones.
+    args.push('--logger', 'trx', '--results-directory', tempDir);
     // Add any additional user-provided args
     args.push(...additionalArgs);
     logger.info('Running dotnet test...');
@@ -3094,7 +3663,308 @@ main();
 
 /***/ }),
 
-/***/ 914:
+/***/ 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:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
@@ -3135,16 +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__(943));
-const fast_xml_parser_1 = __nccwpck_require__(537);
+const fs = __importStar(__nccwpck_require__(1455));
+const fast_xml_parser_1 = __nccwpck_require__(1537);
+const node_crypto_1 = __nccwpck_require__(7598);
+const source_snippets_1 = __nccwpck_require__(148);
 const TOOL_NAME = 'dotnet';
-// Simple UUID v4 generator (avoid extra dependency)
+// Use crypto.randomUUID() for secure UUID generation (available in Node.js 15.7.0+)
 function generateUUID() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-        const r = (Math.random() * 16) | 0;
-        const v = c === 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
+    return (0, node_crypto_1.randomUUID)();
 }
 /**
  * Parse TRX duration string (HH:MM:SS.mmmmmmm) to milliseconds
@@ -3152,13 +4020,22 @@ function generateUUID() {
 function parseDuration(duration) {
     if (!duration)
         return 0;
-    const match = duration.match(/^(\d+):(\d+):(\d+)\.?(\d+)?$/);
-    if (!match)
+    // Use split() instead of regex to avoid ReDoS vulnerability
+    const parts = duration.split(':');
+    if (parts.length !== 3)
         return 0;
-    const hours = parseInt(match[1], 10);
-    const minutes = parseInt(match[2], 10);
-    const seconds = parseInt(match[3], 10);
-    const fraction = match[4] ? parseFloat(`0.${match[4]}`) * 1000 : 0;
+    const hours = parseInt(parts[0], 10);
+    if (Number.isNaN(hours))
+        return 0;
+    const minutes = parseInt(parts[1], 10);
+    if (Number.isNaN(minutes))
+        return 0;
+    // Handle seconds and fractional part (may contain decimal point)
+    const secondsParts = parts[2].split('.');
+    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);
 }
 /**
@@ -3168,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
@@ -3196,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;
 }
@@ -3208,8 +4085,8 @@ function extractLineNumber(stackTrace) {
 function extractFilePath(stackTrace) {
     if (!stackTrace)
         return undefined;
-    // Match file paths ending in .cs
-    const match = stackTrace.match(/([A-Za-z]:\\[^\s:]+\.cs|\/[^\s:]+\.cs)/);
+    // Match file paths ending in .cs with bounded length to prevent ReDoS
+    const match = new RegExp(/([A-Za-z]:\\[^\s:]{1,256}\.cs|\/[^\s:]{1,256}\.cs)/).exec(stackTrace);
     return match ? match[1] : undefined;
 }
 /**
@@ -3243,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;
@@ -3280,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,
@@ -3296,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);
     }
@@ -3401,7 +4289,7 @@ async function parseTrxFiles(trxPaths) {
 
 /***/ }),
 
-/***/ 10:
+/***/ 8010:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
@@ -3409,7 +4297,7 @@ async function parseTrxFiles(trxPaths) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.detectGitContext = void 0;
 exports.uploadToApi = uploadToApi;
-const shared_types_1 = __nccwpck_require__(322);
+const shared_types_1 = __nccwpck_require__(7322);
 /**
  * Upload CTRF report to Testream API
  */
@@ -3436,7 +4324,7 @@ exports.detectGitContext = shared_types_1.detectCIContext;
 
 /***/ }),
 
-/***/ 317:
+/***/ 5317:
 /***/ ((module) => {
 
 "use strict";
@@ -3444,7 +4332,7 @@ module.exports = require("child_process");
 
 /***/ }),
 
-/***/ 896:
+/***/ 9896:
 /***/ ((module) => {
 
 "use strict";
@@ -3452,7 +4340,7 @@ module.exports = require("fs");
 
 /***/ }),
 
-/***/ 943:
+/***/ 1943:
 /***/ ((module) => {
 
 "use strict";
@@ -3460,7 +4348,15 @@ module.exports = require("fs/promises");
 
 /***/ }),
 
-/***/ 474:
+/***/ 7598:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:crypto");
+
+/***/ }),
+
+/***/ 8474:
 /***/ ((module) => {
 
 "use strict";
@@ -3468,7 +4364,7 @@ module.exports = require("node:events");
 
 /***/ }),
 
-/***/ 24:
+/***/ 3024:
 /***/ ((module) => {
 
 "use strict";
@@ -3476,7 +4372,7 @@ module.exports = require("node:fs");
 
 /***/ }),
 
-/***/ 455:
+/***/ 1455:
 /***/ ((module) => {
 
 "use strict";
@@ -3484,7 +4380,7 @@ module.exports = require("node:fs/promises");
 
 /***/ }),
 
-/***/ 760:
+/***/ 6760:
 /***/ ((module) => {
 
 "use strict";
@@ -3492,7 +4388,7 @@ module.exports = require("node:path");
 
 /***/ }),
 
-/***/ 75:
+/***/ 7075:
 /***/ ((module) => {
 
 "use strict";
@@ -3500,7 +4396,7 @@ module.exports = require("node:stream");
 
 /***/ }),
 
-/***/ 193:
+/***/ 6193:
 /***/ ((module) => {
 
 "use strict";
@@ -3508,7 +4404,7 @@ module.exports = require("node:string_decoder");
 
 /***/ }),
 
-/***/ 136:
+/***/ 3136:
 /***/ ((module) => {
 
 "use strict";
@@ -3524,7 +4420,7 @@ module.exports = require("os");
 
 /***/ }),
 
-/***/ 928:
+/***/ 6928:
 /***/ ((module) => {
 
 "use strict";
@@ -3532,7 +4428,7 @@ module.exports = require("path");
 
 /***/ }),
 
-/***/ 80:
+/***/ 7080:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -3598,14 +4494,14 @@ exports.range = range;
 
 /***/ }),
 
-/***/ 339:
+/***/ 2339:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.expand = expand;
-const balanced_match_1 = __nccwpck_require__(80);
+const balanced_match_1 = __nccwpck_require__(7080);
 const escSlash = '\0SLASH' + Math.random() + '\0';
 const escOpen = '\0OPEN' + Math.random() + '\0';
 const escClose = '\0CLOSE' + Math.random() + '\0';
@@ -3801,18 +4697,18 @@ function expand_(str, isTop) {
 
 /***/ }),
 
-/***/ 809:
+/***/ 8809:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Glob = void 0;
-const minimatch_1 = __nccwpck_require__(647);
-const node_url_1 = __nccwpck_require__(136);
-const path_scurry_1 = __nccwpck_require__(125);
-const pattern_js_1 = __nccwpck_require__(841);
-const walker_js_1 = __nccwpck_require__(89);
+const minimatch_1 = __nccwpck_require__(6647);
+const node_url_1 = __nccwpck_require__(3136);
+const path_scurry_1 = __nccwpck_require__(5125);
+const pattern_js_1 = __nccwpck_require__(2841);
+const walker_js_1 = __nccwpck_require__(6089);
 // if no process global, just call it linux.
 // so we default to case-sensitive, / separators
 const defaultPlatform = (typeof process === 'object' &&
@@ -4055,14 +4951,14 @@ exports.Glob = Glob;
 
 /***/ }),
 
-/***/ 233:
+/***/ 6233:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.hasMagic = void 0;
-const minimatch_1 = __nccwpck_require__(647);
+const minimatch_1 = __nccwpck_require__(6647);
 /**
  * Return true if the patterns provided contain any magic glob characters,
  * given the options provided.
@@ -4089,7 +4985,7 @@ exports.hasMagic = hasMagic;
 
 /***/ }),
 
-/***/ 449:
+/***/ 6449:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
@@ -4100,8 +4996,8 @@ exports.hasMagic = hasMagic;
 // Ignores are always parsed in dot:true mode
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Ignore = void 0;
-const minimatch_1 = __nccwpck_require__(647);
-const pattern_js_1 = __nccwpck_require__(841);
+const minimatch_1 = __nccwpck_require__(6647);
+const pattern_js_1 = __nccwpck_require__(2841);
 const defaultPlatform = (typeof process === 'object' &&
     process &&
     typeof process.platform === 'string') ?
@@ -4227,17 +5123,17 @@ exports.globStream = globStream;
 exports.globSync = globSync;
 exports.globIterateSync = globIterateSync;
 exports.globIterate = globIterate;
-const minimatch_1 = __nccwpck_require__(647);
-const glob_js_1 = __nccwpck_require__(809);
-const has_magic_js_1 = __nccwpck_require__(233);
-var minimatch_2 = __nccwpck_require__(647);
+const minimatch_1 = __nccwpck_require__(6647);
+const glob_js_1 = __nccwpck_require__(8809);
+const has_magic_js_1 = __nccwpck_require__(6233);
+var minimatch_2 = __nccwpck_require__(6647);
 Object.defineProperty(exports, "escape", ({ enumerable: true, get: function () { return minimatch_2.escape; } }));
 Object.defineProperty(exports, "unescape", ({ enumerable: true, get: function () { return minimatch_2.unescape; } }));
-var glob_js_2 = __nccwpck_require__(809);
+var glob_js_2 = __nccwpck_require__(8809);
 Object.defineProperty(exports, "Glob", ({ enumerable: true, get: function () { return glob_js_2.Glob; } }));
-var has_magic_js_2 = __nccwpck_require__(233);
+var has_magic_js_2 = __nccwpck_require__(6233);
 Object.defineProperty(exports, "hasMagic", ({ enumerable: true, get: function () { return has_magic_js_2.hasMagic; } }));
-var ignore_js_1 = __nccwpck_require__(449);
+var ignore_js_1 = __nccwpck_require__(6449);
 Object.defineProperty(exports, "Ignore", ({ enumerable: true, get: function () { return ignore_js_1.Ignore; } }));
 function globStreamSync(pattern, options = {}) {
     return new glob_js_1.Glob(pattern, options).streamSync();
@@ -4290,7 +5186,7 @@ exports.glob.glob = exports.glob;
 
 /***/ }),
 
-/***/ 841:
+/***/ 2841:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
@@ -4298,7 +5194,7 @@ exports.glob.glob = exports.glob;
 // this is just a very light wrapper around 2 arrays with an offset index
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Pattern = void 0;
-const minimatch_1 = __nccwpck_require__(647);
+const minimatch_1 = __nccwpck_require__(6647);
 const isPatternList = (pl) => pl.length >= 1;
 const isGlobList = (gl) => gl.length >= 1;
 /**
@@ -4516,7 +5412,7 @@ exports.Pattern = Pattern;
 
 /***/ }),
 
-/***/ 999:
+/***/ 7999:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
@@ -4524,7 +5420,7 @@ exports.Pattern = Pattern;
 // synchronous utility for filtering entries and calculating subwalks
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Processor = exports.SubWalks = exports.MatchRecord = exports.HasWalkedCache = void 0;
-const minimatch_1 = __nccwpck_require__(647);
+const minimatch_1 = __nccwpck_require__(6647);
 /**
  * A cache of which patterns have been processed for a given Path
  */
@@ -4824,7 +5720,7 @@ exports.Processor = Processor;
 
 /***/ }),
 
-/***/ 89:
+/***/ 6089:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
@@ -4837,9 +5733,9 @@ exports.GlobStream = exports.GlobWalker = exports.GlobUtil = void 0;
  *
  * @module
  */
-const minipass_1 = __nccwpck_require__(31);
-const ignore_js_1 = __nccwpck_require__(449);
-const processor_js_1 = __nccwpck_require__(999);
+const minipass_1 = __nccwpck_require__(1031);
+const ignore_js_1 = __nccwpck_require__(6449);
+const processor_js_1 = __nccwpck_require__(7999);
 const makeIgnore = (ignore, opts) => typeof ignore === 'string' ? new ignore_js_1.Ignore([ignore], opts)
     : Array.isArray(ignore) ? new ignore_js_1.Ignore(ignore, opts)
         : ignore;
@@ -5218,7 +6114,7 @@ exports.GlobStream = GlobStream;
 
 /***/ }),
 
-/***/ 481:
+/***/ 3481:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -6831,7 +7727,7 @@ exports.assertValidPattern = assertValidPattern;
 
 /***/ }),
 
-/***/ 743:
+/***/ 8743:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
@@ -6839,8 +7735,8 @@ exports.assertValidPattern = assertValidPattern;
 // parse a single path portion
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AST = void 0;
-const brace_expressions_js_1 = __nccwpck_require__(694);
-const unescape_js_1 = __nccwpck_require__(967);
+const brace_expressions_js_1 = __nccwpck_require__(6694);
+const unescape_js_1 = __nccwpck_require__(7967);
 const types = new Set(['!', '?', '+', '*', '@']);
 const isExtglobType = (c) => types.has(c);
 // Patterns that get prepended to bind to the start of either the
@@ -7429,7 +8325,7 @@ exports.AST = AST;
 
 /***/ }),
 
-/***/ 694:
+/***/ 6694:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -7588,7 +8484,7 @@ exports.parseClass = parseClass;
 
 /***/ }),
 
-/***/ 516:
+/***/ 7516:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -7625,18 +8521,18 @@ exports.escape = escape;
 
 /***/ }),
 
-/***/ 647:
+/***/ 6647:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.unescape = exports.escape = exports.AST = exports.Minimatch = exports.match = exports.makeRe = exports.braceExpand = exports.defaults = exports.filter = exports.GLOBSTAR = exports.sep = exports.minimatch = void 0;
-const brace_expansion_1 = __nccwpck_require__(339);
+const brace_expansion_1 = __nccwpck_require__(2339);
 const assert_valid_pattern_js_1 = __nccwpck_require__(557);
-const ast_js_1 = __nccwpck_require__(743);
-const escape_js_1 = __nccwpck_require__(516);
-const unescape_js_1 = __nccwpck_require__(967);
+const ast_js_1 = __nccwpck_require__(8743);
+const escape_js_1 = __nccwpck_require__(7516);
+const unescape_js_1 = __nccwpck_require__(7967);
 const minimatch = (p, pattern, options = {}) => {
     (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
     // shortcut: comments match nothing.
@@ -8646,11 +9542,11 @@ class Minimatch {
 }
 exports.Minimatch = Minimatch;
 /* c8 ignore start */
-var ast_js_2 = __nccwpck_require__(743);
+var ast_js_2 = __nccwpck_require__(8743);
 Object.defineProperty(exports, "AST", ({ enumerable: true, get: function () { return ast_js_2.AST; } }));
-var escape_js_2 = __nccwpck_require__(516);
+var escape_js_2 = __nccwpck_require__(7516);
 Object.defineProperty(exports, "escape", ({ enumerable: true, get: function () { return escape_js_2.escape; } }));
-var unescape_js_2 = __nccwpck_require__(967);
+var unescape_js_2 = __nccwpck_require__(7967);
 Object.defineProperty(exports, "unescape", ({ enumerable: true, get: function () { return unescape_js_2.unescape; } }));
 /* c8 ignore stop */
 exports.minimatch.AST = ast_js_1.AST;
@@ -8661,7 +9557,7 @@ exports.minimatch.unescape = unescape_js_1.unescape;
 
 /***/ }),
 
-/***/ 967:
+/***/ 7967:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -8706,7 +9602,7 @@ exports.unescape = unescape;
 
 /***/ }),
 
-/***/ 31:
+/***/ 1031:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
@@ -8722,9 +9618,9 @@ const proc = typeof process === 'object' && process
         stdout: null,
         stderr: null,
     };
-const node_events_1 = __nccwpck_require__(474);
-const node_stream_1 = __importDefault(__nccwpck_require__(75));
-const node_string_decoder_1 = __nccwpck_require__(193);
+const node_events_1 = __nccwpck_require__(8474);
+const node_stream_1 = __importDefault(__nccwpck_require__(7075));
+const node_string_decoder_1 = __nccwpck_require__(6193);
 /**
  * Return true if the argument is a Minipass stream, Node stream, or something
  * else that Minipass can interact with.
@@ -9741,7 +10637,7 @@ exports.Minipass = Minipass;
 
 /***/ }),
 
-/***/ 125:
+/***/ 5125:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
@@ -9771,16 +10667,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.PathScurry = exports.Path = exports.PathScurryDarwin = exports.PathScurryPosix = exports.PathScurryWin32 = exports.PathScurryBase = exports.PathPosix = exports.PathWin32 = exports.PathBase = exports.ChildrenCache = exports.ResolveCache = void 0;
-const lru_cache_1 = __nccwpck_require__(481);
-const node_path_1 = __nccwpck_require__(760);
-const node_url_1 = __nccwpck_require__(136);
-const fs_1 = __nccwpck_require__(896);
-const actualFS = __importStar(__nccwpck_require__(24));
+const lru_cache_1 = __nccwpck_require__(3481);
+const node_path_1 = __nccwpck_require__(6760);
+const node_url_1 = __nccwpck_require__(3136);
+const fs_1 = __nccwpck_require__(9896);
+const actualFS = __importStar(__nccwpck_require__(3024));
 const realpathSync = fs_1.realpathSync.native;
 // TODO: test perf of fs/promises realpath vs realpathCB,
 // since the promises one uses realpath.native
-const promises_1 = __nccwpck_require__(455);
-const minipass_1 = __nccwpck_require__(31);
+const promises_1 = __nccwpck_require__(1455);
+const minipass_1 = __nccwpck_require__(1031);
 const defaultFS = {
     lstatSync: fs_1.lstatSync,
     readdir: fs_1.readdir,
@@ -11866,7 +12762,7 @@ exports.PathScurry = process.platform === 'win32' ? PathScurryWin32
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __nccwpck_require__(328);
+/******/ 	var __webpack_exports__ = __nccwpck_require__(4328);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()