@loadstrike/loadstrike-sdk 0.1.0

package/dist/cjs/reporting.js

@@ -0,0 +1,1250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDotnetTxtReport = buildDotnetTxtReport;
+exports.buildDotnetCsvReport = buildDotnetCsvReport;
+exports.buildDotnetMarkdownReport = buildDotnetMarkdownReport;
+exports.buildDotnetHtmlReport = buildDotnetHtmlReport;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = require("node:path");
+const REPORT_EOL = node_os_1.default.EOL;
+const REPORT_FALLBACK_SVG = "<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 128 128'><defs><linearGradient id='g' x1='0' y1='0' x2='1' y2='1'><stop offset='0' stop-color='#64b5ff'/><stop offset='1' stop-color='#2f66db'/></linearGradient></defs><rect width='128' height='128' rx='24' fill='#081325'/><path d='M24 94L56 24l16 34 14-22 18 58h-16l-7-23-9 13-10-21-14 31H24z' fill='url(#g)'/></svg>";
+const REPORT_LOGO_CACHE = new Map();
+function appendReportLine(parts, text = "") {
+    parts.push(text, REPORT_EOL);
+}
+function reportLines(lines) {
+    return `${lines.join(REPORT_EOL)}${REPORT_EOL}`;
+}
+function reportValue(source, ...keys) {
+    if (!source || typeof source !== "object") {
+        return undefined;
+    }
+    const record = source;
+    for (const key of keys) {
+        if (record[key] !== undefined && record[key] !== null) {
+            return record[key];
+        }
+    }
+    return undefined;
+}
+function reportObject(source, ...keys) {
+    const value = reportValue(source, ...keys);
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function reportArray(source, ...keys) {
+    const value = reportValue(source, ...keys);
+    return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+    return value == null ? "" : String(value);
+}
+function asInt(value) {
+    if (typeof value === "boolean") {
+        return value ? 1 : 0;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.trunc(value);
+    }
+    const parsed = Number.parseInt(asString(value), 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function asFloat(value) {
+    if (typeof value === "boolean") {
+        return value ? 1 : 0;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    const parsed = Number.parseFloat(asString(value));
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function formatCellValue(value) {
+    if (value == null) {
+        return "";
+    }
+    if (typeof value === "boolean") {
+        return value ? "True" : "False";
+    }
+    return String(value);
+}
+function escapeHtml(value) {
+    return formatCellValue(value)
+        .split("&").join("&amp;")
+        .split("<").join("&lt;")
+        .split(">").join("&gt;")
+        .split("\"").join("&quot;")
+        .split("'").join("&#39;");
+}
+function escapeCsv(value) {
+    const text = asString(value);
+    return /[,"\n\r]/.test(text)
+        ? `"${text.split("\"").join("\"\"")}"`
+        : text;
+}
+function formatReportNumber(value) {
+    if (value == null) {
+        return "";
+    }
+    return asFloat(value).toFixed(3).replace(/\.?0+$/, "");
+}
+function parseDotnetTimeSpan(value) {
+    let text = value.trim();
+    if (!text) {
+        return undefined;
+    }
+    let sign = 1;
+    if (text.startsWith("+") || text.startsWith("-")) {
+        sign = text.startsWith("-") ? -1 : 1;
+        text = text.slice(1);
+    }
+    let days = 0;
+    if (text.includes(".") && text.split(":").length === 3 && text.indexOf(".") < text.indexOf(":")) {
+        const dayIndex = text.indexOf(".");
+        const dayText = text.slice(0, dayIndex);
+        if (!/^\d+$/.test(dayText)) {
+            return undefined;
+        }
+        days = Number.parseInt(dayText, 10);
+        text = text.slice(dayIndex + 1);
+    }
+    const parts = text.split(":");
+    if (parts.length !== 3) {
+        return undefined;
+    }
+    const [hoursText, minutesText, secondsAndFraction] = parts;
+    let secondsText = secondsAndFraction;
+    let fractionText = "";
+    if (secondsAndFraction.includes(".")) {
+        [secondsText, fractionText] = secondsAndFraction.split(".", 2);
+    }
+    if (!/^\d+$/.test(hoursText) || !/^\d+$/.test(minutesText) || !/^\d+$/.test(secondsText)) {
+        return undefined;
+    }
+    const hours = Number.parseInt(hoursText, 10);
+    const minutes = Number.parseInt(minutesText, 10);
+    const seconds = Number.parseInt(secondsText, 10);
+    const ticks = fractionText ? Number.parseInt((fractionText + "0000000").slice(0, 7), 10) : 0;
+    const milliseconds = ((((days * 24) + hours) * 60 + minutes) * 60 + seconds) * 1000 + (ticks / 10000);
+    return sign * milliseconds;
+}
+function coerceReportDurationMs(value) {
+    if (typeof value === "string") {
+        const parsed = parseDotnetTimeSpan(value);
+        if (parsed !== undefined) {
+            return parsed;
+        }
+    }
+    return Math.max(asFloat(value), 0);
+}
+function reportDurationSeconds(value) {
+    return Math.max(coerceReportDurationMs(value) / 1000, 0);
+}
+function formatDotnetTimeSpan(value) {
+    const totalTicks = Math.round(coerceReportDurationMs(value) * 10000);
+    const sign = totalTicks < 0 ? "-" : "";
+    let remaining = Math.abs(totalTicks);
+    const ticksPerDay = 24 * 60 * 60 * 10000000;
+    const ticksPerHour = 60 * 60 * 10000000;
+    const ticksPerMinute = 60 * 10000000;
+    const ticksPerSecond = 10000000;
+    const days = Math.floor(remaining / ticksPerDay);
+    remaining %= ticksPerDay;
+    const hours = Math.floor(remaining / ticksPerHour);
+    remaining %= ticksPerHour;
+    const minutes = Math.floor(remaining / ticksPerMinute);
+    remaining %= ticksPerMinute;
+    const seconds = Math.floor(remaining / ticksPerSecond);
+    const ticks = remaining % ticksPerSecond;
+    const base = `${sign}${days > 0 ? `${days}.` : ""}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+    return ticks === 0 ? base : `${base}.${String(ticks).padStart(7, "0")}`;
+}
+function loadStrikeNodeTypeTag(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const record = value;
+        if (record.tag !== undefined) {
+            return asInt(record.tag);
+        }
+        if (record.Tag !== undefined) {
+            return asInt(record.Tag);
+        }
+    }
+    const text = asString(value).trim();
+    switch (text) {
+        case "SingleNode":
+            return 0;
+        case "Coordinator":
+            return 1;
+        case "Agent":
+            return 2;
+        default:
+            return asInt(value);
+    }
+}
+function parseUtcDate(value) {
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value;
+    }
+    const text = asString(value).trim();
+    if (!text) {
+        return undefined;
+    }
+    const exactMatch = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,7}))?Z$/.exec(text);
+    if (exactMatch) {
+        const [, base, fraction = ""] = exactMatch;
+        const milliseconds = fraction ? fraction.padEnd(7, "0").slice(0, 3) : "000";
+        return new Date(`${base}.${milliseconds}Z`);
+    }
+    const parsed = new Date(text);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+function formatDotnetDateTime(value) {
+    const text = asString(value).trim();
+    const exactMatch = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,7}))?Z$/.exec(text);
+    if (exactMatch) {
+        const [, base, fraction = ""] = exactMatch;
+        return `${base}.${fraction.padEnd(7, "0") || "0000000"}Z`;
+    }
+    const date = parseUtcDate(value);
+    if (!date) {
+        return "";
+    }
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const hours = String(date.getUTCHours()).padStart(2, "0");
+    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+    const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+    const fraction = `${String(date.getUTCMilliseconds()).padStart(3, "0")}0000`;
+    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${fraction}Z`;
+}
+function escapeJsonForHtmlScript(value) {
+    return value.split("</").join("<\\/").split("<!--").join("<\\!--");
+}
+function buildReportLogoDataUri(resourceName) {
+    const cached = REPORT_LOGO_CACHE.get(resourceName);
+    if (cached) {
+        return cached;
+    }
+    const filename = resourceName.includes("dark") ? "logo-dark-theme.png" : "logo-light-theme.png";
+    const candidates = [
+        (0, node_path_1.resolve)(process.cwd(), "LoadStrike", "images", filename),
+        (0, node_path_1.resolve)(process.cwd(), "..", "LoadStrike", "images", filename),
+        (0, node_path_1.resolve)(process.cwd(), "..", "..", "LoadStrike", "images", filename),
+        (0, node_path_1.resolve)(process.cwd(), "..", "..", "..", "LoadStrike", "images", filename),
+        (0, node_path_1.resolve)(process.cwd(), "..", "..", "..", "..", "LoadStrike", "images", filename),
+        (0, node_path_1.resolve)(process.cwd(), "assets", filename),
+        (0, node_path_1.resolve)(process.cwd(), "src", "assets", filename),
+        (0, node_path_1.resolve)(process.cwd(), "sdk", "ts", "src", "assets", filename)
+    ];
+    for (const candidate of candidates) {
+        try {
+            if ((0, node_fs_1.existsSync)(candidate)) {
+                const dataUri = `data:image/png;base64,${(0, node_fs_1.readFileSync)(candidate).toString("base64")}`;
+                REPORT_LOGO_CACHE.set(resourceName, dataUri);
+                return dataUri;
+            }
+        }
+        catch {
+            // ignore and continue
+        }
+    }
+    const fallback = `data:image/svg+xml;base64,${Buffer.from(REPORT_FALLBACK_SVG, "utf8").toString("base64")}`;
+    REPORT_LOGO_CACHE.set(resourceName, fallback);
+    return fallback;
+}
+function getReportLogoLightDataUri() {
+    return buildReportLogoDataUri("LoadStrike.Assets.logo.light.png");
+}
+function getReportLogoDarkDataUri() {
+    return buildReportLogoDataUri("LoadStrike.Assets.logo.dark.png");
+}
+function sortBySortIndex(rows) {
+    return [...rows].sort((left, right) => asInt(reportValue(left, "sortIndex", "SortIndex")) - asInt(reportValue(right, "sortIndex", "SortIndex")));
+}
+function buildDotnetTableHtml(rows, wrapInCard = true) {
+    if (!rows.length) {
+        return wrapInCard
+            ? `<div class="card"><div class="table-wrap"><table><tbody><tr><td>No rows.</td></tr></tbody></table></div></div>${REPORT_EOL}`
+            : `<div class="table-wrap"><table><tbody><tr><td>No rows.</td></tr></tbody></table></div>${REPORT_EOL}`;
+    }
+    const headers = [];
+    for (const row of rows) {
+        for (const key of Object.keys(row)) {
+            if (!headers.includes(key)) {
+                headers.push(key);
+            }
+        }
+    }
+    const parts = [];
+    if (wrapInCard) {
+        appendReportLine(parts, "<div class=\"card\">");
+    }
+    appendReportLine(parts, "<div class=\"table-wrap\">");
+    appendReportLine(parts, "<table>");
+    appendReportLine(parts, "<thead><tr>");
+    for (const header of headers) {
+        appendReportLine(parts, `<th>${escapeHtml(header)}</th>`);
+    }
+    appendReportLine(parts, "</tr></thead><tbody>");
+    for (const row of rows) {
+        appendReportLine(parts, "<tr>");
+        for (const header of headers) {
+            appendReportLine(parts, `<td>${escapeHtml(row[header])}</td>`);
+        }
+        appendReportLine(parts, "</tr>");
+    }
+    appendReportLine(parts, "</tbody></table></div>");
+    if (wrapInCard) {
+        appendReportLine(parts, "</div>");
+    }
+    return parts.join("");
+}
+function buildFailedStatusRows(scenarios) {
+    const rows = [];
+    for (const scenario of scenarios) {
+        const scenarioName = asString(reportValue(scenario, "scenarioName", "ScenarioName"));
+        const fail = reportObject(scenario, "fail", "Fail");
+        for (const code of reportArray(fail, "statusCodes", "StatusCodes")) {
+            const count = asInt(reportValue(code, "count", "Count"));
+            const isError = Boolean(reportValue(code, "isError", "IsError"));
+            if (count <= 0 && !isError) {
+                continue;
+            }
+            rows.push({
+                Scope: "Scenario",
+                Scenario: scenarioName,
+                Step: "",
+                StatusCode: asString(reportValue(code, "statusCode", "StatusCode")),
+                Message: asString(reportValue(code, "message", "Message")),
+                Count: count,
+                Percent: asInt(reportValue(code, "percent", "Percent")),
+                IsError: isError
+            });
+        }
+        for (const step of sortBySortIndex(reportArray(scenario, "stepStats", "StepStats"))) {
+            const stepName = asString(reportValue(step, "stepName", "StepName"));
+            const stepFail = reportObject(step, "fail", "Fail");
+            for (const code of reportArray(stepFail, "statusCodes", "StatusCodes")) {
+                const count = asInt(reportValue(code, "count", "Count"));
+                const isError = Boolean(reportValue(code, "isError", "IsError"));
+                if (count <= 0 && !isError) {
+                    continue;
+                }
+                rows.push({
+                    Scope: "Step",
+                    Scenario: scenarioName,
+                    Step: stepName,
+                    StatusCode: asString(reportValue(code, "statusCode", "StatusCode")),
+                    Message: asString(reportValue(code, "message", "Message")),
+                    Count: count,
+                    Percent: asInt(reportValue(code, "percent", "Percent")),
+                    IsError: isError
+                });
+            }
+        }
+    }
+    return rows;
+}
+function readReportRowText(row, ...keys) {
+    for (const key of keys) {
+        if (row[key] !== undefined && row[key] !== null) {
+            return asString(row[key]);
+        }
+    }
+    return "";
+}
+function buildFailedEventRows(plugins) {
+    const rows = [];
+    for (const plugin of plugins) {
+        const pluginName = asString(reportValue(plugin, "pluginName", "PluginName"));
+        for (const table of reportArray(plugin, "tables", "Tables")) {
+            const tableName = asString(reportValue(table, "tableName", "TableName"));
+            const lowerPlugin = pluginName.toLowerCase();
+            const lowerTable = tableName.toLowerCase();
+            const isFailedTable = lowerPlugin.includes("fail")
+                || lowerPlugin.includes("timeout")
+                || lowerTable.includes("fail")
+                || lowerTable.includes("timeout");
+            if (!isFailedTable) {
+                continue;
+            }
+            for (const row of reportArray(table, "rows", "Rows")) {
+                rows.push({
+                    Category: `${pluginName}: ${tableName}`,
+                    OccurredUtc: readReportRowText(row, "OccurredUtc"),
+                    Scenario: readReportRowText(row, "Scenario", "scenarioName"),
+                    Step: readReportRowText(row, "Step", "stepName"),
+                    Source: readReportRowText(row, "Source"),
+                    Destination: readReportRowText(row, "Destination"),
+                    StatusCode: readReportRowText(row, "StatusCode"),
+                    Message: readReportRowText(row, "Message", "message"),
+                    TrackingId: readReportRowText(row, "TrackingId"),
+                    EventId: readReportRowText(row, "EventId"),
+                    LatencyMs: readReportRowText(row, "LatencyMs")
+                });
+            }
+        }
+    }
+    return rows;
+}
+function tryParseReportFloat(value) {
+    const parsed = Number.parseFloat(asString(value));
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function meanNumeric(values) {
+    if (!values.length) {
+        return 0;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function percentileNumeric(values, percentileValue) {
+    if (!values.length) {
+        return 0;
+    }
+    const ordered = [...values].sort((left, right) => left - right);
+    const index = Math.min(Math.max(Math.ceil(percentileValue * ordered.length) - 1, 0), ordered.length - 1);
+    return ordered[index];
+}
+function buildGroupedCorrelationChartPayloads(rows) {
+    const grouped = new Map();
+    for (const row of rows) {
+        const gatherField = readReportRowText(row, "GatherByField") || "<none>";
+        const gatherValue = readReportRowText(row, "GatherByValue") || "<missing>";
+        const key = `${gatherField}\u0000${gatherValue}`;
+        const existing = grouped.get(key);
+        if (existing) {
+            existing.rows.push(row);
+        }
+        else {
+            grouped.set(key, { key: [gatherField, gatherValue], rows: [row] });
+        }
+    }
+    return [...grouped.values()]
+        .filter((group) => group.rows.some((row) => tryParseReportFloat(row.LatencyP50Ms) !== undefined
+        || tryParseReportFloat(row.LatencyP80Ms) !== undefined
+        || tryParseReportFloat(row.LatencyP85Ms) !== undefined
+        || tryParseReportFloat(row.LatencyP90Ms) !== undefined
+        || tryParseReportFloat(row.LatencyP95Ms) !== undefined
+        || tryParseReportFloat(row.LatencyP99Ms) !== undefined))
+        .sort((left, right) => left.key[0] === right.key[0]
+        ? left.key[1].localeCompare(right.key[1])
+        : left.key[0].localeCompare(right.key[0]))
+        .map((group, index) => ({
+        title: `${group.key[0]}: ${group.key[1]}`,
+        subtitle: group.rows.length > 1 ? `Averaged across ${group.rows.length} grouped rows.` : "Single grouped row.",
+        chart: {
+            labels: ["P50", "P80", "P85", "P90", "P95", "P99"],
+            series: [
+                {
+                    name: "Latency",
+                    color: ["#38bdf8", "#22c55e", "#f59e0b", "#a855f7", "#f43f5e", "#06b6d4", "#14b8a6", "#eab308", "#818cf8", "#84cc16"][index % 10],
+                    values: [
+                        meanNumeric(group.rows.map((row) => tryParseReportFloat(row.LatencyP50Ms)).filter((value) => value !== undefined)),
+                        meanNumeric(group.rows.map((row) => tryParseReportFloat(row.LatencyP80Ms)).filter((value) => value !== undefined)),
+                        meanNumeric(group.rows.map((row) => tryParseReportFloat(row.LatencyP85Ms)).filter((value) => value !== undefined)),
+                        meanNumeric(group.rows.map((row) => tryParseReportFloat(row.LatencyP90Ms)).filter((value) => value !== undefined)),
+                        meanNumeric(group.rows.map((row) => tryParseReportFloat(row.LatencyP95Ms)).filter((value) => value !== undefined)),
+                        meanNumeric(group.rows.map((row) => tryParseReportFloat(row.LatencyP99Ms)).filter((value) => value !== undefined))
+                    ]
+                }
+            ]
+        }
+    }));
+}
+function buildUngroupedCorrelationChartPayload(rows) {
+    const grouped = new Map();
+    for (const row of rows) {
+        const scenario = readReportRowText(row, "Scenario");
+        const destination = readReportRowText(row, "Destination");
+        const statusCode = readReportRowText(row, "StatusCode");
+        const latency = tryParseReportFloat(row.LatencyMs);
+        if (!scenario || !destination || !statusCode || latency === undefined) {
+            continue;
+        }
+        const key = `${scenario}\u0000${destination}\u0000${statusCode}`;
+        const existing = grouped.get(key);
+        if (existing) {
+            existing.latencies.push(latency);
+        }
+        else {
+            grouped.set(key, { scenario, destination, statusCode, latencies: [latency] });
+        }
+    }
+    const nameCount = new Map();
+    const series = [...grouped.values()]
+        .sort((left, right) => {
+        const leftKey = `${left.scenario}|${left.destination}|${left.statusCode}`;
+        const rightKey = `${right.scenario}|${right.destination}|${right.statusCode}`;
+        return leftKey.localeCompare(rightKey);
+    })
+        .map((row, index) => {
+        const baseName = row.statusCode.trim() || "status";
+        const key = baseName.toLowerCase();
+        const count = nameCount.get(key) ?? 0;
+        nameCount.set(key, count + 1);
+        return {
+            name: count === 0 ? baseName : `${baseName}-${count + 1}`,
+            color: ["#38bdf8", "#22c55e", "#f59e0b", "#a855f7", "#f43f5e", "#06b6d4", "#14b8a6", "#eab308", "#818cf8", "#84cc16"][index % 10],
+            values: [
+                percentileNumeric(row.latencies, 0.50),
+                percentileNumeric(row.latencies, 0.80),
+                percentileNumeric(row.latencies, 0.85),
+                percentileNumeric(row.latencies, 0.90),
+                percentileNumeric(row.latencies, 0.95),
+                percentileNumeric(row.latencies, 0.99)
+            ]
+        };
+    });
+    return {
+        labels: ["P50", "P80", "P85", "P90", "P95", "P99"],
+        series
+    };
+}
+function classifyStatusCodeBucket(statusCode) {
+    const text = asString(statusCode).trim();
+    if (text.length >= 3 && /\d/.test(text[0])) {
+        switch (text[0]) {
+            case "2":
+                return "2xx";
+            case "3":
+                return "3xx";
+            case "4":
+                return "4xx";
+            case "5":
+                return "5xx";
+            default:
+                return "Other";
+        }
+    }
+    return "Other";
+}
+function formatDotnetPercent(value) {
+    return value.toFixed(2).replace(/\.?0+$/, "");
+}
+function buildSummaryLatencyRow(scenarioName, resultName, measurement) {
+    const request = reportObject(measurement, "request", "Request");
+    const latency = reportObject(measurement, "latency", "Latency");
+    return {
+        Scenario: scenarioName,
+        Result: resultName,
+        Count: asInt(reportValue(request, "count", "Count")),
+        LatencyMinMs: formatReportNumber(reportValue(latency, "minMs", "MinMs")),
+        LatencyMeanMs: formatReportNumber(reportValue(latency, "meanMs", "MeanMs")),
+        LatencyP50Ms: formatReportNumber(reportValue(latency, "percent50", "Percent50")),
+        LatencyP75Ms: formatReportNumber(reportValue(latency, "percent75", "Percent75")),
+        LatencyP95Ms: formatReportNumber(reportValue(latency, "percent95", "Percent95")),
+        LatencyP99Ms: formatReportNumber(reportValue(latency, "percent99", "Percent99")),
+        LatencyMaxMs: formatReportNumber(reportValue(latency, "maxMs", "MaxMs")),
+        LatencyStdDev: formatReportNumber(reportValue(latency, "stdDev", "StdDev"))
+    };
+}
+function buildMeasurementRow(scope, scenarioName, stepName, resultName, measurement) {
+    const request = reportObject(measurement, "request", "Request");
+    const latency = reportObject(measurement, "latency", "Latency");
+    const latencyCount = reportObject(latency, "latencyCount", "LatencyCount");
+    const dataTransfer = reportObject(measurement, "dataTransfer", "DataTransfer");
+    return {
+        Scope: scope,
+        Scenario: scenarioName,
+        Step: stepName,
+        Result: resultName,
+        Count: asInt(reportValue(request, "count", "Count")),
+        Percent: asInt(reportValue(request, "percent", "Percent")),
+        RPS: formatReportNumber(reportValue(request, "rps", "RPS")),
+        LatencyMinMs: formatReportNumber(reportValue(latency, "minMs", "MinMs")),
+        LatencyMeanMs: formatReportNumber(reportValue(latency, "meanMs", "MeanMs")),
+        LatencyP50Ms: formatReportNumber(reportValue(latency, "percent50", "Percent50")),
+        LatencyP75Ms: formatReportNumber(reportValue(latency, "percent75", "Percent75")),
+        LatencyP95Ms: formatReportNumber(reportValue(latency, "percent95", "Percent95")),
+        LatencyP99Ms: formatReportNumber(reportValue(latency, "percent99", "Percent99")),
+        LatencyMaxMs: formatReportNumber(reportValue(latency, "maxMs", "MaxMs")),
+        LatencyStdDev: formatReportNumber(reportValue(latency, "stdDev", "StdDev")),
+        "Latency<=800ms": asInt(reportValue(latencyCount, "lessOrEq800", "LessOrEq800")),
+        "Latency800-1200ms": asInt(reportValue(latencyCount, "more800Less1200", "More800Less1200")),
+        "Latency>=1200ms": asInt(reportValue(latencyCount, "moreOrEq1200", "MoreOrEq1200")),
+        BytesTotal: asInt(reportValue(dataTransfer, "allBytes", "AllBytes")),
+        BytesMin: asInt(reportValue(dataTransfer, "minBytes", "MinBytes")),
+        BytesMean: asInt(reportValue(dataTransfer, "meanBytes", "MeanBytes")),
+        BytesP50: asInt(reportValue(dataTransfer, "percent50", "Percent50")),
+        BytesP75: asInt(reportValue(dataTransfer, "percent75", "Percent75")),
+        BytesP95: asInt(reportValue(dataTransfer, "percent95", "Percent95")),
+        BytesP99: asInt(reportValue(dataTransfer, "percent99", "Percent99")),
+        BytesMax: asInt(reportValue(dataTransfer, "maxBytes", "MaxBytes")),
+        BytesStdDev: formatReportNumber(reportValue(dataTransfer, "stdDev", "StdDev"))
+    };
+}
+function appendChartCard(parts, id, title) {
+    appendReportLine(parts, `<div class="chart-card"><h3>${escapeHtml(title)}</h3><canvas id="${escapeHtml(id)}" class="chart-canvas"></canvas></div>`);
+}
+function hasChartPointData(points) {
+    return Array.isArray(points) && points.length > 0;
+}
+function hasPieChartData(points) {
+    return Array.isArray(points) && points.some((point) => Math.abs(asFloat(reportValue(point, "value", "Value"))) > 0);
+}
+function hasLatencyTrendData(chart) {
+    const labels = reportArray(chart, "labels", "Labels");
+    const series = reportArray(chart, "series", "Series");
+    return labels.length > 0 && series.some((entry) => reportArray(entry, "values", "Values").some((value) => Number.isFinite(asFloat(value))));
+}
+function hasNonEmptyHints(plugin) {
+    return reportArray(plugin, "hints", "Hints").some((hint) => asString(hint).trim().length > 0);
+}
+function buildDotnetScenarioRows(nodeStats) {
+    return sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats")).map((scenario) => ({
+        Scenario: asString(reportValue(scenario, "scenarioName", "ScenarioName")),
+        Simulation: asString(reportValue(reportObject(scenario, "loadSimulationStats", "LoadSimulationStats"), "simulationName", "SimulationName")),
+        SimulationValue: asInt(reportValue(reportObject(scenario, "loadSimulationStats", "LoadSimulationStats"), "value", "Value")),
+        Requests: asInt(reportValue(scenario, "allRequestCount", "AllRequestCount")),
+        OK: asInt(reportValue(scenario, "allOkCount", "AllOkCount")),
+        FAIL: asInt(reportValue(scenario, "allFailCount", "AllFailCount")),
+        Duration: formatDotnetTimeSpan(reportValue(scenario, "duration", "Duration", "durationMs", "DurationMs")),
+        RPS: formatReportNumber(reportDurationSeconds(reportValue(scenario, "duration", "Duration", "durationMs", "DurationMs")) <= 0 ? 0 : asInt(reportValue(scenario, "allRequestCount", "AllRequestCount")) / reportDurationSeconds(reportValue(scenario, "duration", "Duration", "durationMs", "DurationMs"))),
+        LatencyP95Ms: formatReportNumber(Math.max(asFloat(reportValue(reportObject(reportObject(scenario, "ok", "Ok"), "latency", "Latency"), "percent95", "Percent95")), asFloat(reportValue(reportObject(reportObject(scenario, "fail", "Fail"), "latency", "Latency"), "percent95", "Percent95")))),
+        LatencyP99Ms: formatReportNumber(Math.max(asFloat(reportValue(reportObject(reportObject(scenario, "ok", "Ok"), "latency", "Latency"), "percent99", "Percent99")), asFloat(reportValue(reportObject(reportObject(scenario, "fail", "Fail"), "latency", "Latency"), "percent99", "Percent99")))),
+        CurrentOperation: asString(reportValue(scenario, "currentOperation", "CurrentOperation"))
+    }));
+}
+function buildDotnetStepRows(nodeStats) {
+    const rows = [];
+    for (const scenario of sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"))) {
+        for (const step of sortBySortIndex(reportArray(scenario, "stepStats", "StepStats"))) {
+            rows.push({
+                Scenario: asString(reportValue(scenario, "scenarioName", "ScenarioName")),
+                Step: asString(reportValue(step, "stepName", "StepName")),
+                Requests: asInt(reportValue(reportObject(reportObject(step, "ok", "Ok"), "request", "Request"), "count", "Count")) + asInt(reportValue(reportObject(reportObject(step, "fail", "Fail"), "request", "Request"), "count", "Count")),
+                OK: asInt(reportValue(reportObject(reportObject(step, "ok", "Ok"), "request", "Request"), "count", "Count")),
+                FAIL: asInt(reportValue(reportObject(reportObject(step, "fail", "Fail"), "request", "Request"), "count", "Count")),
+                OK_RPS: formatReportNumber(reportValue(reportObject(reportObject(step, "ok", "Ok"), "request", "Request"), "rps", "RPS")),
+                FAIL_RPS: formatReportNumber(reportValue(reportObject(reportObject(step, "fail", "Fail"), "request", "Request"), "rps", "RPS")),
+                LatencyMeanMs: formatReportNumber(Math.max(asFloat(reportValue(reportObject(reportObject(step, "ok", "Ok"), "latency", "Latency"), "meanMs", "MeanMs")), asFloat(reportValue(reportObject(reportObject(step, "fail", "Fail"), "latency", "Latency"), "meanMs", "MeanMs")))),
+                P95LatencyMs: formatReportNumber(Math.max(asFloat(reportValue(reportObject(reportObject(step, "ok", "Ok"), "latency", "Latency"), "percent95", "Percent95")), asFloat(reportValue(reportObject(reportObject(step, "fail", "Fail"), "latency", "Latency"), "percent95", "Percent95"))))
+            });
+        }
+    }
+    return rows;
+}
+function buildDotnetScenarioMeasurementRows(nodeStats) {
+    const rows = [];
+    for (const scenario of sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"))) {
+        const scenarioName = asString(reportValue(scenario, "scenarioName", "ScenarioName"));
+        rows.push(buildMeasurementRow("Scenario", scenarioName, "", "OK", reportObject(scenario, "ok", "Ok")));
+        rows.push(buildMeasurementRow("Scenario", scenarioName, "", "FAIL", reportObject(scenario, "fail", "Fail")));
+    }
+    return rows;
+}
+function buildDotnetStepMeasurementRows(nodeStats) {
+    const rows = [];
+    for (const scenario of sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"))) {
+        const scenarioName = asString(reportValue(scenario, "scenarioName", "ScenarioName"));
+        for (const step of sortBySortIndex(reportArray(scenario, "stepStats", "StepStats"))) {
+            const stepName = asString(reportValue(step, "stepName", "StepName"));
+            rows.push(buildMeasurementRow("Step", scenarioName, stepName, "OK", reportObject(step, "ok", "Ok")));
+            rows.push(buildMeasurementRow("Step", scenarioName, stepName, "FAIL", reportObject(step, "fail", "Fail")));
+        }
+    }
+    return rows;
+}
+function buildDotnetStatusCodeRows(nodeStats) {
+    const rows = [];
+    for (const scenario of sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"))) {
+        const scenarioName = asString(reportValue(scenario, "scenarioName", "ScenarioName"));
+        for (const code of reportArray(reportObject(scenario, "ok", "Ok"), "statusCodes", "StatusCodes")) {
+            rows.push({ Scope: "Scenario", Scenario: scenarioName, Step: "", Result: "OK", StatusCode: asString(reportValue(code, "statusCode", "StatusCode")), Message: asString(reportValue(code, "message", "Message")), Count: asInt(reportValue(code, "count", "Count")), Percent: asInt(reportValue(code, "percent", "Percent")), IsError: Boolean(reportValue(code, "isError", "IsError")) });
+        }
+        for (const code of reportArray(reportObject(scenario, "fail", "Fail"), "statusCodes", "StatusCodes")) {
+            rows.push({ Scope: "Scenario", Scenario: scenarioName, Step: "", Result: "FAIL", StatusCode: asString(reportValue(code, "statusCode", "StatusCode")), Message: asString(reportValue(code, "message", "Message")), Count: asInt(reportValue(code, "count", "Count")), Percent: asInt(reportValue(code, "percent", "Percent")), IsError: Boolean(reportValue(code, "isError", "IsError")) });
+        }
+        for (const step of sortBySortIndex(reportArray(scenario, "stepStats", "StepStats"))) {
+            const stepName = asString(reportValue(step, "stepName", "StepName"));
+            for (const code of reportArray(reportObject(step, "ok", "Ok"), "statusCodes", "StatusCodes")) {
+                rows.push({ Scope: "Step", Scenario: scenarioName, Step: stepName, Result: "OK", StatusCode: asString(reportValue(code, "statusCode", "StatusCode")), Message: asString(reportValue(code, "message", "Message")), Count: asInt(reportValue(code, "count", "Count")), Percent: asInt(reportValue(code, "percent", "Percent")), IsError: Boolean(reportValue(code, "isError", "IsError")) });
+            }
+            for (const code of reportArray(reportObject(step, "fail", "Fail"), "statusCodes", "StatusCodes")) {
+                rows.push({ Scope: "Step", Scenario: scenarioName, Step: stepName, Result: "FAIL", StatusCode: asString(reportValue(code, "statusCode", "StatusCode")), Message: asString(reportValue(code, "message", "Message")), Count: asInt(reportValue(code, "count", "Count")), Percent: asInt(reportValue(code, "percent", "Percent")), IsError: Boolean(reportValue(code, "isError", "IsError")) });
+            }
+        }
+    }
+    return rows;
+}
+function buildDotnetThresholdRows(nodeStats) {
+    return reportArray(nodeStats, "thresholds", "Thresholds").map((threshold) => ({
+        Scenario: asString(reportValue(threshold, "scenarioName", "ScenarioName")),
+        Step: asString(reportValue(threshold, "stepName", "StepName")),
+        Check: asString(reportValue(threshold, "checkExpression", "CheckExpression")),
+        Failed: Boolean(reportValue(threshold, "isFailed", "IsFailed")),
+        ErrorCount: asInt(reportValue(threshold, "errorCount", "ErrorCount")),
+        Exception: asString(reportValue(threshold, "exceptionMessage", "ExceptionMessage", "exceptionMsg", "ExceptionMsg"))
+    }));
+}
+function buildDotnetMetricRows(nodeStats) {
+    const metrics = reportObject(nodeStats, "metrics", "Metrics");
+    const rows = [];
+    for (const counter of reportArray(metrics, "counters", "Counters")) {
+        rows.push({
+            Type: "Counter",
+            Scenario: asString(reportValue(counter, "scenarioName", "ScenarioName")),
+            Name: asString(reportValue(counter, "metricName", "MetricName")),
+            Unit: asString(reportValue(counter, "unitOfMeasure", "UnitOfMeasure")),
+            Value: asInt(reportValue(counter, "value", "Value"))
+        });
+    }
+    for (const gauge of reportArray(metrics, "gauges", "Gauges")) {
+        rows.push({
+            Type: "Gauge",
+            Scenario: asString(reportValue(gauge, "scenarioName", "ScenarioName")),
+            Name: asString(reportValue(gauge, "metricName", "MetricName")),
+            Unit: asString(reportValue(gauge, "unitOfMeasure", "UnitOfMeasure")),
+            Value: formatReportNumber(reportValue(gauge, "value", "Value"))
+        });
+    }
+    return rows;
+}
+function buildDotnetStatusCodeClassChart(scenarios) {
+    const buckets = { "2xx": 0, "3xx": 0, "4xx": 0, "5xx": 0, Other: 0 };
+    for (const scenario of scenarios) {
+        for (const bucket of [reportObject(scenario, "ok", "Ok"), reportObject(scenario, "fail", "Fail")]) {
+            for (const code of reportArray(bucket, "statusCodes", "StatusCodes")) {
+                buckets[classifyStatusCodeBucket(reportValue(code, "statusCode", "StatusCode"))] += asInt(reportValue(code, "count", "Count"));
+            }
+        }
+    }
+    return [
+        { label: "2xx", value: buckets["2xx"], color: "#16a34a" },
+        { label: "3xx", value: buckets["3xx"], color: "#0ea5e9" },
+        { label: "4xx", value: buckets["4xx"], color: "#f59e0b" },
+        { label: "5xx", value: buckets["5xx"], color: "#dc2626" },
+        { label: "Other", value: buckets.Other, color: "#8b5cf6" }
+    ].filter((entry) => entry.value > 0);
+}
+function buildDotnetChartData(nodeStats) {
+    const scenarios = sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"));
+    return {
+        overallOutcome: [
+            { label: "OK", value: asInt(reportValue(nodeStats, "allOkCount", "AllOkCount")), color: "#18a957" },
+            { label: "FAIL", value: asInt(reportValue(nodeStats, "allFailCount", "AllFailCount")), color: "#d14343" }
+        ],
+        scenarioRequests: scenarios.map((scenario) => ({
+            label: asString(reportValue(scenario, "scenarioName", "ScenarioName")),
+            value: asInt(reportValue(scenario, "allRequestCount", "AllRequestCount")),
+            color: "#3b82f6"
+        })),
+        scenarioP95Latency: scenarios.map((scenario) => ({
+            label: asString(reportValue(scenario, "scenarioName", "ScenarioName")),
+            value: Math.max(asFloat(reportValue(reportObject(reportObject(scenario, "ok", "Ok"), "latency", "Latency"), "percent95", "Percent95")), asFloat(reportValue(reportObject(reportObject(scenario, "fail", "Fail"), "latency", "Latency"), "percent95", "Percent95"))),
+            color: "#8b5cf6"
+        })),
+        scenarioRps: scenarios.map((scenario) => ({
+            label: asString(reportValue(scenario, "scenarioName", "ScenarioName")),
+            value: reportDurationSeconds(reportValue(scenario, "duration", "Duration", "durationMs", "DurationMs")) <= 0
+                ? 0
+                : asInt(reportValue(scenario, "allRequestCount", "AllRequestCount")) / reportDurationSeconds(reportValue(scenario, "duration", "Duration", "durationMs", "DurationMs")),
+            color: "#10b981"
+        })),
+        scenarioFailRate: scenarios.map((scenario) => ({
+            label: asString(reportValue(scenario, "scenarioName", "ScenarioName")),
+            value: asInt(reportValue(scenario, "allRequestCount", "AllRequestCount")) <= 0
+                ? 0
+                : (asInt(reportValue(scenario, "allFailCount", "AllFailCount")) * 100 / asInt(reportValue(scenario, "allRequestCount", "AllRequestCount"))),
+            color: "#ef4444"
+        })),
+        scenarioBytes: scenarios.map((scenario) => ({
+            label: asString(reportValue(scenario, "scenarioName", "ScenarioName")),
+            value: asInt(reportValue(scenario, "allBytes", "AllBytes")),
+            color: "#0ea5e9"
+        })),
+        statusCodeClasses: buildDotnetStatusCodeClassChart(scenarios),
+        scenarioLatencyTrend: {
+            labels: scenarios.map((scenario) => asString(reportValue(scenario, "scenarioName", "ScenarioName"))),
+            series: [
+                { name: "P50", color: "#38bdf8", values: scenarios.map((scenario) => Math.max(asFloat(reportValue(reportObject(reportObject(scenario, "ok", "Ok"), "latency", "Latency"), "percent50", "Percent50")), asFloat(reportValue(reportObject(reportObject(scenario, "fail", "Fail"), "latency", "Latency"), "percent50", "Percent50")))) },
+                { name: "P75", color: "#22c55e", values: scenarios.map((scenario) => Math.max(asFloat(reportValue(reportObject(reportObject(scenario, "ok", "Ok"), "latency", "Latency"), "percent75", "Percent75")), asFloat(reportValue(reportObject(reportObject(scenario, "fail", "Fail"), "latency", "Latency"), "percent75", "Percent75")))) },
+                { name: "P95", color: "#f59e0b", values: scenarios.map((scenario) => Math.max(asFloat(reportValue(reportObject(reportObject(scenario, "ok", "Ok"), "latency", "Latency"), "percent95", "Percent95")), asFloat(reportValue(reportObject(reportObject(scenario, "fail", "Fail"), "latency", "Latency"), "percent95", "Percent95")))) },
+                { name: "P99", color: "#f43f5e", values: scenarios.map((scenario) => Math.max(asFloat(reportValue(reportObject(reportObject(scenario, "ok", "Ok"), "latency", "Latency"), "percent99", "Percent99")), asFloat(reportValue(reportObject(reportObject(scenario, "fail", "Fail"), "latency", "Latency"), "percent99", "Percent99")))) }
+            ]
+        }
+    };
+}
+function buildDotnetSummaryHtml(nodeStats) {
+    const scenarios = sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"));
+    const successRate = asInt(reportValue(nodeStats, "allRequestCount", "AllRequestCount")) <= 0
+        ? 0
+        : (asInt(reportValue(nodeStats, "allOkCount", "AllOkCount")) * 100 / asInt(reportValue(nodeStats, "allRequestCount", "AllRequestCount")));
+    const failRate = asInt(reportValue(nodeStats, "allRequestCount", "AllRequestCount")) <= 0
+        ? 0
+        : (asInt(reportValue(nodeStats, "allFailCount", "AllFailCount")) * 100 / asInt(reportValue(nodeStats, "allRequestCount", "AllRequestCount")));
+    const overallRps = reportDurationSeconds(reportValue(nodeStats, "duration", "Duration", "durationMs", "DurationMs")) <= 0
+        ? 0
+        : asInt(reportValue(nodeStats, "allRequestCount", "AllRequestCount")) / reportDurationSeconds(reportValue(nodeStats, "duration", "Duration", "durationMs", "DurationMs"));
+    const topScenario = scenarios.reduce((winner, scenario) => {
+        if (!winner) {
+            return scenario;
+        }
+        return asInt(reportValue(scenario, "allRequestCount", "AllRequestCount")) > asInt(reportValue(winner, "allRequestCount", "AllRequestCount"))
+            ? scenario
+            : winner;
+    }, undefined);
+    const latencyRows = scenarios.flatMap((scenario) => [
+        buildSummaryLatencyRow(asString(reportValue(scenario, "scenarioName", "ScenarioName")), "OK", reportObject(scenario, "ok", "Ok")),
+        buildSummaryLatencyRow(asString(reportValue(scenario, "scenarioName", "ScenarioName")), "FAIL", reportObject(scenario, "fail", "Fail"))
+    ]);
+    const chartData = buildDotnetChartData(nodeStats);
+    const testInfo = reportObject(nodeStats, "testInfo", "TestInfo");
+    const nodeInfo = reportObject(nodeStats, "nodeInfo", "NodeInfo");
+    const parts = [];
+    appendReportLine(parts, "<div class=\"card-grid\">");
+    appendReportLine(parts, `<div class="stat-card"><div class="stat-label">Total Requests</div><div class="stat-value">${asInt(reportValue(nodeStats, "allRequestCount", "AllRequestCount"))}</div></div>`);
+    appendReportLine(parts, `<div class="stat-card"><div class="stat-label">Success</div><div class="stat-value value-ok">${asInt(reportValue(nodeStats, "allOkCount", "AllOkCount"))} (${formatDotnetPercent(successRate)}%)</div></div>`);
+    appendReportLine(parts, `<div class="stat-card"><div class="stat-label">Fail</div><div class="stat-value value-fail">${asInt(reportValue(nodeStats, "allFailCount", "AllFailCount"))} (${formatDotnetPercent(failRate)}%)</div></div>`);
+    appendReportLine(parts, `<div class="stat-card"><div class="stat-label">Overall RPS</div><div class="stat-value">${formatReportNumber(overallRps)}</div></div>`);
+    appendReportLine(parts, `<div class="stat-card"><div class="stat-label">Duration</div><div class="stat-value">${escapeHtml(formatDotnetTimeSpan(reportValue(nodeStats, "duration", "Duration", "durationMs", "DurationMs")))}</div></div>`);
+    appendReportLine(parts, `<div class="stat-card"><div class="stat-label">Total Bytes</div><div class="stat-value">${asInt(reportValue(nodeStats, "allBytes", "AllBytes"))}</div></div>`);
+    appendReportLine(parts, `<div class="stat-card"><div class="stat-label">Top Scenario</div><div class="stat-value">${escapeHtml(topScenario ? reportValue(topScenario, "scenarioName", "ScenarioName") : "n/a")}</div></div>`);
+    appendReportLine(parts, `<div class="stat-card"><div class="stat-label">Node</div><div class="stat-value">${loadStrikeNodeTypeTag(reportValue(nodeInfo, "nodeType", "NodeType"))}</div></div>`);
+    appendReportLine(parts, "</div>");
+    const charts = [];
+    if (hasPieChartData(chartData.overallOutcome)) {
+        appendChartCard(charts, "chart-outcome", "Success vs Fail");
+    }
+    if (hasChartPointData(chartData.scenarioRequests)) {
+        appendChartCard(charts, "chart-scenario-requests", "Requests by Scenario");
+    }
+    if (hasChartPointData(chartData.scenarioP95Latency)) {
+        appendChartCard(charts, "chart-scenario-p95", "P95 Latency by Scenario (ms)");
+    }
+    if (hasChartPointData(chartData.scenarioRps)) {
+        appendChartCard(charts, "chart-scenario-rps", "RPS by Scenario");
+    }
+    if (hasChartPointData(chartData.scenarioFailRate)) {
+        appendChartCard(charts, "chart-scenario-fail-rate", "Failure Rate by Scenario (%)");
+    }
+    if (hasChartPointData(chartData.scenarioBytes)) {
+        appendChartCard(charts, "chart-scenario-bytes", "Bytes by Scenario");
+    }
+    if (hasPieChartData(chartData.statusCodeClasses)) {
+        appendChartCard(charts, "chart-status-code-classes", "Status Code Class Mix");
+    }
+    if (hasLatencyTrendData(chartData.scenarioLatencyTrend)) {
+        appendChartCard(charts, "chart-scenario-latency-lines", "Latency Trend by Scenario (ms)");
+    }
+    if (charts.length > 0) {
+        appendReportLine(parts, "<div class=\"card\">");
+        appendReportLine(parts, "<h2>Charts</h2>");
+        appendReportLine(parts, "<div class=\"chart-grid\">");
+        parts.push(...charts);
+        appendReportLine(parts, "</div>");
+        appendReportLine(parts, "</div>");
+    }
+    if (latencyRows.length > 0) {
+        appendReportLine(parts, "<div class=\"card\">");
+        appendReportLine(parts, "<h2>Latency by Scenario (Table)</h2>");
+        parts.push(buildDotnetTableHtml(latencyRows, false));
+        appendReportLine(parts);
+        appendReportLine(parts, "</div>");
+    }
+    appendReportLine(parts, "<div class=\"card\">");
+    appendReportLine(parts, "<h2>Environment</h2>");
+    appendReportLine(parts, "<div class=\"table-wrap\"><table><tbody>");
+    appendReportLine(parts, `<tr><th>Cluster Id</th><td>${escapeHtml(reportValue(testInfo, "clusterId", "ClusterId"))}</td></tr>`);
+    appendReportLine(parts, `<tr><th>Created (UTC)</th><td>${escapeHtml(formatDotnetDateTime(reportValue(testInfo, "createdUtc", "CreatedUtc", "created", "Created")))}</td></tr>`);
+    appendReportLine(parts, `<tr><th>Machine</th><td>${escapeHtml(reportValue(nodeInfo, "machineName", "MachineName"))}</td></tr>`);
+    appendReportLine(parts, `<tr><th>OS</th><td>${escapeHtml(reportValue(nodeInfo, "os", "OS"))}</td></tr>`);
+    appendReportLine(parts, `<tr><th>DotNet</th><td>${escapeHtml(reportValue(nodeInfo, "dotNetVersion", "DotNetVersion"))}</td></tr>`);
+    appendReportLine(parts, `<tr><th>Processor</th><td>${escapeHtml(reportValue(nodeInfo, "processor", "Processor"))}</td></tr>`);
+    appendReportLine(parts, `<tr><th>Cores</th><td>${asInt(reportValue(nodeInfo, "coresCount", "CoresCount"))}</td></tr>`);
+    appendReportLine(parts, `<tr><th>Operation</th><td>${escapeHtml(reportValue(nodeInfo, "currentOperation", "CurrentOperation"))}</td></tr>`);
+    appendReportLine(parts, "</tbody></table></div>");
+    appendReportLine(parts, "</div>");
+    return parts.join("");
+}
+function buildDotnetScenarioHtml(nodeStats) {
+    return buildDotnetTableHtml(buildDotnetScenarioRows(nodeStats));
+}
+function buildDotnetStepHtml(nodeStats) {
+    return buildDotnetTableHtml(buildDotnetStepRows(nodeStats));
+}
+function buildDotnetScenarioMeasurementHtml(nodeStats) {
+    return buildDotnetTableHtml(buildDotnetScenarioMeasurementRows(nodeStats));
+}
+function buildDotnetStepMeasurementHtml(nodeStats) {
+    return buildDotnetTableHtml(buildDotnetStepMeasurementRows(nodeStats));
+}
+function buildDotnetStatusCodeHtml(nodeStats) {
+    return buildDotnetTableHtml(buildDotnetStatusCodeRows(nodeStats));
+}
+function buildDotnetFailedResponseHtml(nodeStats) {
+    const failedStatusRows = buildFailedStatusRows(sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats")));
+    const failedEventRows = buildFailedEventRows(reportArray(nodeStats, "pluginsData", "PluginsData"));
+    return buildDotnetFailedResponseContent(failedStatusRows, failedEventRows);
+}
+function buildDotnetFailedResponseContent(failedStatusRows, failedEventRows) {
+    const parts = [];
+    if (failedStatusRows.length > 0) {
+        appendReportLine(parts, "<div class=\"card\">");
+        appendReportLine(parts, "<h2>Failed Status Codes</h2>");
+        parts.push(buildDotnetTableHtml(failedStatusRows, false));
+        appendReportLine(parts);
+        appendReportLine(parts, "</div>");
+    }
+    if (failedEventRows.length > 0) {
+        appendReportLine(parts, "<div class=\"card\">");
+        appendReportLine(parts, "<h2>Failed and Timed Out Rows</h2>");
+        parts.push(buildDotnetTableHtml(failedEventRows, false));
+        appendReportLine(parts);
+        appendReportLine(parts, "</div>");
+    }
+    return parts.join("");
+}
+function buildDotnetThresholdHtml(nodeStats) {
+    return buildDotnetTableHtml(buildDotnetThresholdRows(nodeStats));
+}
+function buildDotnetMetricHtml(nodeStats) {
+    return buildDotnetTableHtml(buildDotnetMetricRows(nodeStats));
+}
+function buildDotnetGroupedCorrelationSummaryHtml(rows, groupedChartKey) {
+    const parts = [];
+    const payloads = buildGroupedCorrelationChartPayloads(rows);
+    parts.push(buildDotnetTableHtml(rows));
+    if (!payloads.length) {
+        return parts.join("");
+    }
+    appendReportLine(parts);
+    appendReportLine(parts, "<div class=\"card\"><h2>Grouped Correlation Percentile Trends</h2><p>Each chart is one GatherBy value. The line shows latency progression across P50 to P99.</p></div>");
+    appendReportLine(parts, "<div class=\"chart-grid correlation-chart-grid\">");
+    payloads.forEach((payload, index) => {
+        const chartKey = `${groupedChartKey}-value-${index}`;
+        const chartJson = escapeJsonForHtmlScript(JSON.stringify(payload.chart));
+        appendReportLine(parts, `<script type="application/json" data-grouped-correlation-chart="${escapeHtml(chartKey)}">${chartJson}</script>`);
+        appendReportLine(parts, `<div class="chart-card correlation-chart-card"><h3>${escapeHtml(payload.title)}</h3><p>${escapeHtml(payload.subtitle)}</p><canvas class="chart-canvas grouped-correlation-canvas" data-grouped-key="${escapeHtml(chartKey)}"></canvas></div>`);
+    });
+    appendReportLine(parts, "</div>");
+    return parts.join("");
+}
+function buildDotnetUngroupedCorrelationSummaryHtml(rows, groupedChartKey) {
+    const chart = buildUngroupedCorrelationChartPayload(rows);
+    const parts = [];
+    parts.push(buildDotnetTableHtml(rows));
+    if (hasLatencyTrendData(chart)) {
+        const chartJson = escapeJsonForHtmlScript(JSON.stringify(chart));
+        appendReportLine(parts);
+        appendReportLine(parts, "<div class=\"card\"><h2>Ungrouped Correlation Percentile Trends</h2><p>All percentile lines are shown in one graph for direct comparison.</p></div>");
+        appendReportLine(parts, `<script type="application/json" data-ungrouped-correlation="${escapeHtml(groupedChartKey)}">${chartJson}</script>`);
+        appendReportLine(parts, "<div class=\"chart-grid correlation-chart-grid\">");
+        appendReportLine(parts, `<div class="chart-card correlation-chart-card"><h3>Ungrouped Correlation Percentiles</h3><canvas class="chart-canvas ungrouped-correlation-canvas" data-ungrouped-key="${escapeHtml(groupedChartKey)}"></canvas></div>`);
+        appendReportLine(parts, "</div>");
+    }
+    return parts.join("");
+}
+function buildDotnetPluginHints(plugin) {
+    if (!hasNonEmptyHints(plugin)) {
+        return "";
+    }
+    const hints = reportArray(plugin, "hints", "Hints").map((hint) => asString(hint).trim()).filter((hint) => hint.length > 0);
+    return `<div class="card"><strong>Hints</strong><ul>${hints.map((hint) => `<li>${escapeHtml(hint)}</li>`).join("")}</ul></div>`;
+}
+function buildDotnetHtmlTabs(nodeStats) {
+    const tabs = [["summary", "Summary", buildDotnetSummaryHtml(nodeStats)]];
+    const scenarioRows = buildDotnetScenarioRows(nodeStats);
+    if (scenarioRows.length) {
+        tabs.push(["scenarios", "Scenarios", buildDotnetTableHtml(scenarioRows)]);
+    }
+    const scenarioMeasurementRows = buildDotnetScenarioMeasurementRows(nodeStats);
+    if (scenarioMeasurementRows.length) {
+        tabs.push(["scenario-measurements", "Scenario Measurements", buildDotnetTableHtml(scenarioMeasurementRows)]);
+    }
+    const stepRows = buildDotnetStepRows(nodeStats);
+    if (stepRows.length) {
+        tabs.push(["steps", "Steps", buildDotnetTableHtml(stepRows)]);
+    }
+    const stepMeasurementRows = buildDotnetStepMeasurementRows(nodeStats);
+    if (stepMeasurementRows.length) {
+        tabs.push(["step-measurements", "Step Measurements", buildDotnetTableHtml(stepMeasurementRows)]);
+    }
+    const statusCodeRows = buildDotnetStatusCodeRows(nodeStats);
+    if (statusCodeRows.length) {
+        tabs.push(["status-codes", "Status Codes", buildDotnetTableHtml(statusCodeRows)]);
+    }
+    const failedStatusRows = buildFailedStatusRows(sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats")));
+    const failedEventRows = buildFailedEventRows(reportArray(nodeStats, "pluginsData", "PluginsData"));
+    if (failedStatusRows.length || failedEventRows.length) {
+        tabs.push(["failed-responses", "Failed Responses", buildDotnetFailedResponseContent(failedStatusRows, failedEventRows)]);
+    }
+    const thresholdRows = buildDotnetThresholdRows(nodeStats);
+    if (thresholdRows.length) {
+        tabs.push(["thresholds", "Thresholds", buildDotnetTableHtml(thresholdRows)]);
+    }
+    const metricRows = buildDotnetMetricRows(nodeStats);
+    if (metricRows.length) {
+        tabs.push(["metrics", "Metrics", buildDotnetTableHtml(metricRows)]);
+    }
+    for (const plugin of reportArray(nodeStats, "pluginsData", "PluginsData")) {
+        const pluginName = asString(reportValue(plugin, "pluginName", "PluginName"));
+        const hints = buildDotnetPluginHints(plugin);
+        const lowerPlugin = pluginName.toLowerCase();
+        const skipMergedPluginTab = lowerPlugin.includes("failed") || lowerPlugin.includes("correlation");
+        const tables = reportArray(plugin, "tables", "Tables");
+        if (!tables.length) {
+            if (skipMergedPluginTab) {
+                continue;
+            }
+            if (!hints) {
+                continue;
+            }
+            tabs.push([`plugin-${tabs.length}`, pluginName, hints]);
+            continue;
+        }
+        for (const table of tables) {
+            const tableName = asString(reportValue(table, "tableName", "TableName"));
+            const lowerTable = tableName.toLowerCase();
+            const bodyRows = reportArray(table, "rows", "Rows").map((row) => ({ ...row }));
+            if (lowerPlugin.includes("failed") || lowerTable.includes("failed")) {
+                continue;
+            }
+            if (!bodyRows.length) {
+                continue;
+            }
+            let title = `${pluginName}: ${tableName}`;
+            let body = buildDotnetTableHtml(bodyRows);
+            if (lowerPlugin.includes("correlation") && lowerTable.includes("grouped correlation summary")) {
+                title = "Grouped Correlation Summary";
+                body = buildDotnetGroupedCorrelationSummaryHtml(bodyRows, `grouped-correlation-${tabs.length}`);
+            }
+            else if (lowerPlugin.includes("correlation") && lowerTable.includes("ungrouped correlation rows")) {
+                title = "Ungrouped Corelation Summary";
+                body = buildDotnetUngroupedCorrelationSummaryHtml(bodyRows, `ungrouped-correlation-${tabs.length}`);
+            }
+            tabs.push([`plugin-${tabs.length}`, title, `${hints}${body}`]);
+        }
+    }
+    return tabs;
+}
+function buildDotnetTxtReport(nodeStats) {
+    const scenarios = sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"));
+    const testInfo = reportObject(nodeStats, "testInfo", "TestInfo");
+    const nodeInfo = reportObject(nodeStats, "nodeInfo", "NodeInfo");
+    const lines = [
+        `TestSuite: ${asString(reportValue(testInfo, "testSuite", "TestSuite"))}`,
+        `TestName: ${asString(reportValue(testInfo, "testName", "TestName"))}`,
+        `SessionId: ${asString(reportValue(testInfo, "sessionId", "SessionId"))}`,
+        `NodeType: ${loadStrikeNodeTypeTag(reportValue(nodeInfo, "nodeType", "NodeType"))}`,
+        `Duration: ${formatDotnetTimeSpan(reportValue(nodeStats, "duration", "Duration", "durationMs", "DurationMs"))}`,
+        `Requests: ${asInt(reportValue(nodeStats, "allRequestCount", "AllRequestCount"))}  OK: ${asInt(reportValue(nodeStats, "allOkCount", "AllOkCount"))}  FAIL: ${asInt(reportValue(nodeStats, "allFailCount", "AllFailCount"))}`,
+        "",
+        "Scenarios:"
+    ];
+    for (const scenario of scenarios) {
+        lines.push(`- ${asString(reportValue(scenario, "scenarioName", "ScenarioName"))}: req=${asInt(reportValue(scenario, "allRequestCount", "AllRequestCount"))} ok=${asInt(reportValue(scenario, "allOkCount", "AllOkCount"))} fail=${asInt(reportValue(scenario, "allFailCount", "AllFailCount"))} duration=${formatDotnetTimeSpan(reportValue(scenario, "duration", "Duration", "durationMs", "DurationMs"))}`);
+    }
+    if (scenarios.some((scenario) => reportArray(scenario, "stepStats", "StepStats").length > 0)) {
+        lines.push("", "Steps:");
+        for (const scenario of scenarios) {
+            for (const step of sortBySortIndex(reportArray(scenario, "stepStats", "StepStats"))) {
+                const ok = asInt(reportValue(reportObject(reportObject(step, "ok", "Ok"), "request", "Request"), "count", "Count"));
+                const fail = asInt(reportValue(reportObject(reportObject(step, "fail", "Fail"), "request", "Request"), "count", "Count"));
+                lines.push(`- ${asString(reportValue(scenario, "scenarioName", "ScenarioName"))}.${asString(reportValue(step, "stepName", "StepName"))}: req=${ok + fail} ok=${ok} fail=${fail}`);
+            }
+        }
+    }
+    const thresholds = reportArray(nodeStats, "thresholds", "Thresholds");
+    if (thresholds.length) {
+        lines.push("", "Thresholds:");
+        for (const threshold of thresholds) {
+            lines.push(`- scenario=${asString(reportValue(threshold, "scenarioName", "ScenarioName"))} step=${asString(reportValue(threshold, "stepName", "StepName"))} check=${asString(reportValue(threshold, "checkExpression", "CheckExpression"))} failed=${formatCellValue(Boolean(reportValue(threshold, "isFailed", "IsFailed")))} errors=${asInt(reportValue(threshold, "errorCount", "ErrorCount"))} message=${asString(reportValue(threshold, "exceptionMessage", "ExceptionMessage", "exceptionMsg", "ExceptionMsg"))}`);
+        }
+    }
+    const plugins = reportArray(nodeStats, "pluginsData", "PluginsData");
+    if (plugins.length) {
+        lines.push("", "Plugin Tables:");
+        for (const plugin of plugins) {
+            lines.push(`- ${asString(reportValue(plugin, "pluginName", "PluginName"))}`);
+            for (const table of reportArray(plugin, "tables", "Tables")) {
+                lines.push(`  Table: ${asString(reportValue(table, "tableName", "TableName"))} rows=${reportArray(table, "rows", "Rows").length}`);
+            }
+        }
+    }
+    return reportLines(lines);
+}
+function buildDotnetCsvReport(nodeStats) {
+    const lines = ["ScenarioName,Requests,Ok,Fail,DurationSeconds,Rps"];
+    for (const scenario of sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"))) {
+        const durationSeconds = reportDurationSeconds(reportValue(scenario, "duration", "Duration", "durationMs", "DurationMs"));
+        const requests = asInt(reportValue(scenario, "allRequestCount", "AllRequestCount"));
+        lines.push(`${escapeCsv(reportValue(scenario, "scenarioName", "ScenarioName"))},${requests},${asInt(reportValue(scenario, "allOkCount", "AllOkCount"))},${asInt(reportValue(scenario, "allFailCount", "AllFailCount"))},${formatReportNumber(durationSeconds)},${formatReportNumber(durationSeconds <= 0 ? 0 : requests / durationSeconds)}`);
+    }
+    return reportLines(lines);
+}
+function buildDotnetMarkdownReport(nodeStats) {
+    const scenarios = sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"));
+    const testInfo = reportObject(nodeStats, "testInfo", "TestInfo");
+    const lines = [
+        `# ${asString(reportValue(testInfo, "testSuite", "TestSuite"))} / ${asString(reportValue(testInfo, "testName", "TestName"))}`,
+        "",
+        `- Session: \`${asString(reportValue(testInfo, "sessionId", "SessionId"))}\``,
+        `- Duration: \`${formatDotnetTimeSpan(reportValue(nodeStats, "duration", "Duration", "durationMs", "DurationMs"))}\``,
+        `- Total Requests: \`${asInt(reportValue(nodeStats, "allRequestCount", "AllRequestCount"))}\``,
+        `- OK: \`${asInt(reportValue(nodeStats, "allOkCount", "AllOkCount"))}\``,
+        `- FAIL: \`${asInt(reportValue(nodeStats, "allFailCount", "AllFailCount"))}\``,
+        "",
+        "## Scenarios",
+        "",
+        "| Scenario | Requests | OK | FAIL | Duration |",
+        "|---|---:|---:|---:|---:|"
+    ];
+    for (const scenario of scenarios) {
+        lines.push(`| ${asString(reportValue(scenario, "scenarioName", "ScenarioName"))} | ${asInt(reportValue(scenario, "allRequestCount", "AllRequestCount"))} | ${asInt(reportValue(scenario, "allOkCount", "AllOkCount"))} | ${asInt(reportValue(scenario, "allFailCount", "AllFailCount"))} | ${formatReportNumber(reportDurationSeconds(reportValue(scenario, "duration", "Duration", "durationMs", "DurationMs")))}s |`);
+    }
+    if (scenarios.some((scenario) => reportArray(scenario, "stepStats", "StepStats").length > 0)) {
+        lines.push("", "## Steps", "", "| Scenario | Step | Requests | OK | FAIL |", "|---|---|---:|---:|---:|");
+        for (const scenario of scenarios) {
+            for (const step of sortBySortIndex(reportArray(scenario, "stepStats", "StepStats"))) {
+                const ok = asInt(reportValue(reportObject(reportObject(step, "ok", "Ok"), "request", "Request"), "count", "Count"));
+                const fail = asInt(reportValue(reportObject(reportObject(step, "fail", "Fail"), "request", "Request"), "count", "Count"));
+                lines.push(`| ${asString(reportValue(scenario, "scenarioName", "ScenarioName"))} | ${asString(reportValue(step, "stepName", "StepName"))} | ${ok + fail} | ${ok} | ${fail} |`);
+            }
+        }
+    }
+    const thresholds = reportArray(nodeStats, "thresholds", "Thresholds");
+    if (thresholds.length) {
+        lines.push("", "## Thresholds", "", "| Scenario | Step | Check | Failed | Errors | Exception |", "|---|---|---|---:|---:|---|");
+        for (const threshold of thresholds) {
+            lines.push(`| ${asString(reportValue(threshold, "scenarioName", "ScenarioName"))} | ${asString(reportValue(threshold, "stepName", "StepName"))} | ${asString(reportValue(threshold, "checkExpression", "CheckExpression"))} | ${formatCellValue(Boolean(reportValue(threshold, "isFailed", "IsFailed")))} | ${asInt(reportValue(threshold, "errorCount", "ErrorCount"))} | ${asString(reportValue(threshold, "exceptionMessage", "ExceptionMessage", "exceptionMsg", "ExceptionMsg"))} |`);
+        }
+    }
+    return reportLines(lines);
+}
+function buildDotnetHtmlReport(nodeStats) {
+    const tabs = buildDotnetHtmlTabs(nodeStats);
+    const buttonsHtml = tabs.map(([tabId, title]) => `<button class="tab-btn" data-tab="${tabId}">${escapeHtml(title)}</button>${REPORT_EOL}`).join("");
+    const sectionsHtml = tabs.map(([tabId, , html]) => `<section id="${tabId}" class="tab">${html}</section>${REPORT_EOL}`).join("");
+    const chartDataJson = JSON.stringify(buildDotnetChartData(nodeStats));
+    const testInfo = reportObject(nodeStats, "testInfo", "TestInfo");
+    const template = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>LoadStrike Report</title>
+<style>
+:root{--bg:#f4f7fc;--bgTop:#fff3d0;--bgRight:#dbe8ff;--bgBottom:#edf2fb;--panel:#ffffff;--panelAlt:#eef3fb;--line:#d3deed;--text:#0f172a;--muted:#4b5563;--accent:#2563eb;--ok:#138a4a;--fail:#c63636;--warn:#b7791f;--chip:#edf3fc;--card:#ffffff;--stat:#f5f9ff;--chartPanel:#0f172a;--chartGrid:#334155;--chartAxis:#b5c2d3;--chartLabel:#dbe6f4;--chartDot:#0f172a;--chartPieCenter:#0f172a;--chartPieCenterText:#e5eefc;--chartLegendText:#e6edf3;--shadow:0 10px 24px rgba(15,23,42,.1)}
+body[data-theme='dark']{--bg:#0d1117;--bgTop:#18243b;--bgRight:#102235;--bgBottom:#0b0f14;--panel:#111827;--panelAlt:#0f172a;--line:#263241;--text:#e6edf3;--muted:#9fb0c3;--accent:#2563eb;--ok:#18a957;--fail:#d14343;--warn:#f59e0b;--chip:rgba(31,41,55,.45);--card:linear-gradient(180deg,rgba(17,24,39,.92) 0,rgba(13,19,32,.92) 100%);--stat:rgba(20,30,47,.65);--chartPanel:rgba(15,23,42,.72);--chartGrid:#334155;--chartAxis:#b5c2d3;--chartLabel:#dbe6f4;--chartDot:#0f172a;--chartPieCenter:#0f172a;--chartPieCenterText:#e5eefc;--chartLegendText:#e6edf3;--shadow:0 10px 24px rgba(0,0,0,.2)}
+body{margin:0;background:radial-gradient(1200px 700px at 10% -10%,var(--bgTop) 0,transparent 58%),radial-gradient(900px 620px at 100% 0,var(--bgRight) 0,transparent 57%),var(--bgBottom);color:var(--text);font-family:'Segoe UI',Tahoma,sans-serif}
+.wrap{max-width:1440px;margin:0 auto;padding:20px}
+.report-brand{display:flex;align-items:center;gap:16px;margin:0 0 10px 0;overflow:visible;padding-top:8px;flex-wrap:wrap}
+.report-logo-slot{width:380px;height:184px;max-width:100%;flex:0 0 auto;display:flex;align-items:flex-start;justify-content:flex-start;overflow:visible}
+.report-logo{width:100%;height:100%;object-fit:contain;object-position:left top;border:none;background:transparent;box-shadow:none;border-radius:0;padding:0;margin:0;overflow:visible;transform:scale(var(--report-logo-scale,1));transform-origin:left top;transition:transform .2s ease}
+body[data-theme='dark'] .report-logo{--report-logo-scale:1.175}
+.theme-toggle-report{position:fixed;top:12px;right:12px;z-index:1200;display:inline-flex;align-items:center;justify-content:center;width:40px;height:40px;appearance:none;border:1px solid var(--line);background:var(--chip);color:var(--text);padding:0;border-radius:999px;font-size:18px;font-weight:700;cursor:pointer;transition:all .2s ease}
+.theme-toggle-report:hover{border-color:var(--accent);transform:translateY(-1px)}
+.theme-toggle-report span{line-height:1;pointer-events:none}
+h1{margin:0 0 10px 0;font-size:28px;letter-spacing:.2px}
+h2{margin:0 0 12px 0;font-size:18px}
+h3{margin:0 0 10px 0;font-size:15px;color:var(--text)}
+.meta{display:flex;gap:14px;flex-wrap:wrap;color:var(--muted);font-size:13px;margin-bottom:16px}
+.meta span{background:var(--chip);border:1px solid var(--line);padding:6px 10px;border-radius:999px}
+.report-layout{display:grid;grid-template-columns:280px minmax(0,1fr);gap:14px;align-items:start}
+.tabs-pane{position:sticky;top:12px;max-height:calc(100vh - 24px);overflow:auto;overscroll-behavior:contain;padding-right:4px;cursor:grab}
+.tabs-pane.panning{cursor:grabbing;user-select:none}
+.tabs{display:flex;flex-direction:column;gap:8px;margin:12px 0 14px 0}
+.tab-btn{background:var(--panelAlt);color:var(--text);border:1px solid var(--line);padding:8px 12px;border-radius:8px;cursor:pointer;transition:all .2s ease;text-align:left;width:100%}
+.tab-btn:hover{border-color:var(--accent);background:var(--chip)}
+.tab-btn.active{background:linear-gradient(180deg,#2f66db 0,#2754b8 100%);border-color:#3f73e0}
+.tabs-content{min-width:0}
+.tab{display:none}
+.tab.active{display:block}
+table{width:100%;border-collapse:collapse;font-size:12px}
+th,td{border:1px solid var(--line);padding:7px 8px;text-align:left;vertical-align:top}
+th{background:var(--panelAlt);position:sticky;top:0;z-index:1}
+.card{background:var(--card);border:1px solid var(--line);border-radius:12px;padding:14px;margin-bottom:14px;box-shadow:var(--shadow)}
+.card-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:10px;margin-bottom:14px}
+.stat-card{padding:10px 12px;border-radius:10px;border:1px solid var(--line);background:var(--stat)}
+.stat-label{font-size:12px;color:var(--muted)}
+.stat-value{font-size:22px;font-weight:700;margin-top:4px}
+.value-ok{color:var(--ok)}
+.value-fail{color:var(--fail)}
+.chart-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(360px,1fr));gap:12px}
+.chart-card{padding:12px;border:1px solid var(--line);border-radius:10px;background:var(--chartPanel)}
+.chart-canvas{width:100%;height:260px;display:block}
+.correlation-chart-grid{grid-template-columns:repeat(auto-fit,minmax(420px,720px));justify-content:center}
+.correlation-chart-card{max-width:720px;width:100%}
+.correlation-chart-card .chart-canvas{height:320px}
+.chart-card h3,.chart-card p{color:var(--chartLegendText)}
+.table-wrap{overflow:auto;max-height:70vh}
+@media (max-width:980px){.wrap{padding:14px}.report-brand{margin-bottom:8px;padding-top:4px}.report-logo-slot{width:300px;height:146px}.theme-toggle-report{top:10px;right:10px}.report-layout{grid-template-columns:1fr}.tabs-pane{position:static;max-height:none;cursor:auto}.tabs{flex-direction:row;flex-wrap:wrap}.tab-btn{width:auto}.chart-canvas{height:220px}.correlation-chart-grid{grid-template-columns:1fr;justify-content:stretch}.correlation-chart-card{max-width:none}.correlation-chart-card .chart-canvas{height:280px}.stat-value{font-size:18px}}
+</style>
+</head>
+<body data-theme="light">
+<div class="wrap">
+<button type="button" class="theme-toggle-report" data-report-theme-toggle aria-label="Switch to dark theme" aria-pressed="false" title="Switch to dark theme"><span aria-hidden="true">&#x263E;</span></button>
+<div class="report-brand">
+<div class="report-logo-slot">
+<img src="__LOGO_LIGHT__" alt="LoadStrike logo" class="report-logo" data-report-logo data-logo-light="__LOGO_LIGHT__" data-logo-dark="__LOGO_DARK__" />
+</div>
+<h1>LoadStrike Report</h1>
+</div>
+<div class="meta">
+<span>Suite: <strong>__TEST_SUITE__</strong></span>
+<span>Name: <strong>__TEST_NAME__</strong></span>
+<span>Session: <strong>__SESSION_ID__</strong></span>
+<span>Duration: <strong>__DURATION__</strong></span>
+</div>
+<div class="report-layout">
+<aside class="tabs-pane" id="tab-pane">
+<div class="tabs">
+__BUTTONS__</div>
+</aside>
+<div class="tabs-content">
+__SECTIONS__</div>
+</div>
+</div>
+<script>
+const reportCharts=__CHART_DATA__;
+const btns=[...document.querySelectorAll('.tab-btn')];
+const tabSections=[...document.querySelectorAll('.tab')];
+const tabsPane=document.getElementById('tab-pane');
+const linePalette=['#38bdf8','#22c55e','#f59e0b','#a855f7','#f43f5e','#14b8a6','#eab308','#818cf8','#06b6d4','#84cc16'];
+const reportThemeKey='loadstrike-report-theme';
+const reportThemeToggle=document.querySelector('[data-report-theme-toggle]');
+const reportLogo=document.querySelector('[data-report-logo]');
+function applyReportTheme(theme){const normalized=theme==='dark'?'dark':'light';document.body.setAttribute('data-theme',normalized);if(reportLogo){const lightLogo=reportLogo.dataset.logoLight||reportLogo.getAttribute('src');const darkLogo=reportLogo.dataset.logoDark||reportLogo.getAttribute('src');reportLogo.setAttribute('src',normalized==='dark'?darkLogo:lightLogo);}if(reportThemeToggle){const darkActive=normalized==='dark';const nextLabel=darkActive?'light':'dark';reportThemeToggle.innerHTML=darkActive?'&#x2600;':'&#x263E;';reportThemeToggle.setAttribute('aria-pressed',darkActive?'true':'false');reportThemeToggle.setAttribute('aria-label','Switch to '+nextLabel+' theme');reportThemeToggle.setAttribute('title','Switch to '+nextLabel+' theme');}}
+function show(id){btns.forEach(b=>b.classList.toggle('active',b.dataset.tab===id));tabSections.forEach(t=>t.classList.toggle('active',t.id===id));}
+function formatMetric(v){if(!Number.isFinite(v))return '0';return Math.abs(v)>=100?v.toFixed(0):v.toFixed(2);}
+function setupCanvas(canvas){const dpr=window.devicePixelRatio||1;const w=Math.max(320,canvas.clientWidth||320);const h=Math.max(220,canvas.clientHeight||220);canvas.width=Math.floor(w*dpr);canvas.height=Math.floor(h*dpr);const ctx=canvas.getContext('2d');ctx.setTransform(dpr,0,0,dpr,0,0);return {ctx,w,h};}
+function drawNoData(ctx,w,h,msg){ctx.fillStyle='#9fb0c3';ctx.font='13px Segoe UI';ctx.textAlign='center';ctx.fillText(msg,w/2,h/2);}
+function drawBar(canvasId,points){const canvas=document.getElementById(canvasId);if(!canvas)return;const c=setupCanvas(canvas);const ctx=c.ctx,w=c.w,h=c.h;ctx.clearRect(0,0,w,h);if(!points||points.length===0){drawNoData(ctx,w,h,'No data');return;}const left=46,right=14,top=16,bottom=62;const pw=w-left-right;const ph=h-top-bottom;const max=Math.max(...points.map(p=>p.value),1);ctx.strokeStyle='#334155';ctx.lineWidth=1;for(let i=0;i<=4;i++){const y=top+(ph*(i/4));ctx.beginPath();ctx.moveTo(left,y);ctx.lineTo(w-right,y);ctx.stroke();}const slot=pw/points.length;const bar=Math.max(8,slot*0.58);ctx.font='11px Segoe UI';for(let i=0;i<points.length;i++){const p=points[i];const x=left+i*slot+(slot-bar)/2;const bh=(p.value/max)*ph;const y=top+ph-bh;ctx.fillStyle=p.color||'#3b82f6';ctx.fillRect(x,y,bar,bh);ctx.fillStyle='#dbe6f4';ctx.textAlign='center';ctx.fillText(formatMetric(p.value),x+bar/2,Math.max(12,y-4));ctx.save();ctx.translate(x+bar/2,h-bottom+14);ctx.rotate(-0.6);ctx.fillStyle='#b5c2d3';ctx.fillText((p.label||'').slice(0,26),0,0);ctx.restore();}ctx.fillStyle='#b5c2d3';ctx.textAlign='right';for(let i=0;i<=4;i++){const value=max*(1-i/4);const y=top+(ph*(i/4))+4;ctx.fillText(formatMetric(value),left-6,y);}}
+function drawPie(canvasId,points){const canvas=document.getElementById(canvasId);if(!canvas)return;const c=setupCanvas(canvas);const ctx=c.ctx,w=c.w,h=c.h;ctx.clearRect(0,0,w,h);if(!points||points.length===0){drawNoData(ctx,w,h,'No data');return;}const total=points.reduce((s,p)=>s+(p.value||0),0);if(total<=0){drawNoData(ctx,w,h,'No data');return;}const cx=w*0.35,cy=h*0.5,r=Math.min(w,h)*0.28;let angle=-Math.PI/2;for(const p of points){const val=Math.max(0,p.value||0);const delta=(val/total)*Math.PI*2;ctx.beginPath();ctx.moveTo(cx,cy);ctx.arc(cx,cy,r,angle,angle+delta);ctx.closePath();ctx.fillStyle=p.color||'#3b82f6';ctx.fill();angle+=delta;}ctx.fillStyle='#0f172a';ctx.beginPath();ctx.arc(cx,cy,r*0.54,0,Math.PI*2);ctx.fill();ctx.fillStyle='#e5eefc';ctx.font='bold 18px Segoe UI';ctx.textAlign='center';ctx.fillText(total.toString(),cx,cy+6);ctx.font='12px Segoe UI';ctx.fillStyle='#9fb0c3';ctx.fillText('requests',cx,cy+24);ctx.textAlign='left';let y=cy-r+10;for(const p of points){ctx.fillStyle=p.color||'#3b82f6';ctx.fillRect(w*0.64,y-10,12,12);ctx.fillStyle='#e6edf3';ctx.font='12px Segoe UI';const pct=total<=0?0:((p.value/total)*100);ctx.fillText(\`\${p.label}: \${p.value} (\${pct.toFixed(1)}%)\`,w*0.64+18,y);y+=20;}}
+function drawLatencyLine(canvasRef,chart){const canvas=typeof canvasRef==='string'?document.getElementById(canvasRef):canvasRef;if(!canvas)return;const c=setupCanvas(canvas);const ctx=c.ctx,w=c.w,h=c.h;ctx.clearRect(0,0,w,h);if(!chart||!Array.isArray(chart.labels)||chart.labels.length===0||!Array.isArray(chart.series)||chart.series.length===0){drawNoData(ctx,w,h,'No latency data');return;}const labels=chart.labels;const seriesList=chart.series;const allValues=seriesList.flatMap(s=>(s.values||[]).filter(v=>Number.isFinite(v)));if(allValues.length===0){drawNoData(ctx,w,h,'No latency data');return;}const shortAxisLabels=labels.every(label=>((label||'').toString().length<=4));const rotateAxisLabels=!shortAxisLabels&&labels.length>4;const left=52,right=18,bottom=rotateAxisLabels?78:52;const legendItemWidth=150,legendLineHeight=14,legendTop=12;const plotWidth=Math.max(120,w-left-right);const legendCols=Math.max(1,Math.floor(plotWidth/legendItemWidth));const legendRows=Math.max(1,Math.ceil(seriesList.length/legendCols));const legendHeight=legendRows*legendLineHeight;const top=legendTop+legendHeight+16;const pw=w-left-right;const ph=h-top-bottom;if(ph<=20){drawNoData(ctx,w,h,'No latency data');return;}const max=Math.max(...allValues,1);const scaleMax=max*1.08;ctx.strokeStyle='#334155';ctx.lineWidth=1;for(let i=0;i<=4;i++){const y=top+(ph*(i/4));ctx.beginPath();ctx.moveTo(left,y);ctx.lineTo(w-right,y);ctx.stroke();}ctx.fillStyle='#b5c2d3';ctx.font='11px Segoe UI';ctx.textAlign='right';for(let i=0;i<=4;i++){const value=max*(1-i/4);const y=top+(ph*(i/4))+4;ctx.fillText(formatMetric(value),left-6,y);}const xStep=labels.length<=1?0:pw/(labels.length-1);const xAt=i=>labels.length<=1?left+(pw/2):left+(xStep*i);const overlapOffset=new Map();const epsilon=Math.max(max*0.0005,0.001);for(let pointIndex=0;pointIndex<labels.length;pointIndex++){const points=[];for(let seriesIndex=0;seriesIndex<seriesList.length;seriesIndex++){const value=(seriesList[seriesIndex].values||[])[pointIndex];if(Number.isFinite(value)){points.push({seriesIndex,value});}}points.sort((a,b)=>a.value===b.value?a.seriesIndex-b.seriesIndex:a.value-b.value);let start=0;while(start<points.length){let end=start+1;while(end<points.length&&Math.abs(points[end].value-points[start].value)<=epsilon){end++;}const count=end-start;if(count>1){const mid=(count-1)/2;for(let k=0;k<count;k++){overlapOffset.set(points[start+k].seriesIndex+'|'+pointIndex,(k-mid)*3);}}start=end;}}const dashPatterns=[[0,0],[7,4],[2,3],[10,3,2,3]];for(let seriesIndex=0;seriesIndex<seriesList.length;seriesIndex++){const series=seriesList[seriesIndex];ctx.beginPath();ctx.strokeStyle=series.color||'#38bdf8';ctx.lineWidth=2.2;const dash=dashPatterns[seriesIndex%dashPatterns.length];if(dash[0]===0){ctx.setLineDash([]);}else{ctx.setLineDash(dash);}let started=false;(series.values||[]).forEach((value,index)=>{if(!Number.isFinite(value)){started=false;return;}const x=xAt(index);const offset=overlapOffset.get(seriesIndex+'|'+index)||0;const y=top+ph-((value/scaleMax)*ph)+offset;if(!started){ctx.moveTo(x,y);started=true;}else{ctx.lineTo(x,y);}});ctx.stroke();ctx.setLineDash([]);(series.values||[]).forEach((value,index)=>{if(!Number.isFinite(value))return;const x=xAt(index);const offset=overlapOffset.get(seriesIndex+'|'+index)||0;const y=top+ph-((value/scaleMax)*ph)+offset;ctx.beginPath();ctx.fillStyle='#0f172a';ctx.arc(x,y,3.2,0,Math.PI*2);ctx.fill();ctx.beginPath();ctx.strokeStyle=series.color||'#38bdf8';ctx.lineWidth=2;ctx.arc(x,y,3.2,0,Math.PI*2);ctx.stroke();});}ctx.fillStyle='#b5c2d3';ctx.font='10px Segoe UI';ctx.textAlign='center';labels.forEach((label,index)=>{const x=xAt(index);const text=(label||'').toString().slice(0,34);if(rotateAxisLabels){ctx.save();ctx.translate(x,h-bottom+12);ctx.rotate(-0.6);ctx.fillText(text,0,0);ctx.restore();}else{ctx.fillText(text,x,h-bottom+16);}});let lx=left,ly=legendTop+2;for(let seriesIndex=0;seriesIndex<seriesList.length;seriesIndex++){const series=seriesList[seriesIndex];const rawName=(series.name||'Series').toString();const legendName=rawName.length>30?rawName.slice(0,27)+'...':rawName;ctx.strokeStyle=series.color||'#38bdf8';ctx.lineWidth=2.2;const dash=dashPatterns[seriesIndex%dashPatterns.length];if(dash[0]===0){ctx.setLineDash([]);}else{ctx.setLineDash(dash);}ctx.beginPath();ctx.moveTo(lx,ly+1.5);ctx.lineTo(lx+12,ly+1.5);ctx.stroke();ctx.setLineDash([]);ctx.fillStyle='#b5c2d3';ctx.font='11px Segoe UI';ctx.textAlign='left';ctx.fillText(legendName,lx+16,ly+4);lx+=legendItemWidth;if(lx>w-right-legendItemWidth){lx=left;ly+=legendLineHeight;}}}
+function renderCharts(){drawPie('chart-outcome',reportCharts.overallOutcome);drawBar('chart-scenario-requests',reportCharts.scenarioRequests);drawBar('chart-scenario-p95',reportCharts.scenarioP95Latency);drawBar('chart-scenario-rps',reportCharts.scenarioRps);drawBar('chart-scenario-fail-rate',reportCharts.scenarioFailRate);drawBar('chart-scenario-bytes',reportCharts.scenarioBytes);drawPie('chart-status-code-classes',reportCharts.statusCodeClasses);drawLatencyLine('chart-scenario-latency-lines',reportCharts.scenarioLatencyTrend);}
+function getGroupedCorrelationChart(key){const node=document.querySelector('script[type="application/json"][data-grouped-correlation-chart="'+key+'"]');if(!node)return {labels:[],series:[]};try{return JSON.parse(node.textContent||'{"labels":[],"series":[]}');}catch{return {labels:[],series:[]};}}
+function getUngroupedCorrelationChart(key){const node=document.querySelector('script[type="application/json"][data-ungrouped-correlation="'+key+'"]');if(!node)return {labels:[],series:[]};try{return JSON.parse(node.textContent||'{"labels":[],"series":[]}');}catch{return {labels:[],series:[]};}}
+function normalizeUngroupedCorrelationChart(chart){if(!chart||!Array.isArray(chart.labels)||!Array.isArray(chart.series))return {labels:[],series:[]};const compactName=input=>{const raw=(input||'Series').toString();const parts=raw.split('|').map(x=>x.trim()).filter(x=>x.length>0);const tail=parts.length>0?parts[parts.length-1]:raw.trim();if(tail.length===0)return 'Series';return tail.length>22?tail.slice(0,19)+'...':tail;};const labels=chart.labels||[];const series=chart.series||[];const normalizedSeries=series.map((item,index)=>({name:compactName(item&&item.name),color:(item&&item.color)||linePalette[index%linePalette.length],values:Array.isArray(item&&item.values)?item.values.map(v=>Number.isFinite(v)?v:NaN):[]})).filter(s=>s.values.some(v=>Number.isFinite(v)));const isPercentile=value=>/^p\\d+$/i.test((value||'').toString().trim());const labelsArePercentiles=labels.length>0&&labels.every(isPercentile);if(labelsArePercentiles){return {labels,series:normalizedSeries};}const seriesArePercentiles=normalizedSeries.length>0&&normalizedSeries.every(s=>isPercentile(s.name));if(!seriesArePercentiles||labels.length===0){return {labels,series:normalizedSeries};}const percentileLabels=normalizedSeries.map(s=>s.name.toUpperCase());const reshaped=labels.map((label,labelIndex)=>{const values=normalizedSeries.map(s=>{const value=s.values[labelIndex];return Number.isFinite(value)?value:NaN;});return {name:compactName(label||('Series '+(labelIndex+1))),color:linePalette[labelIndex%linePalette.length],values};}).filter(s=>s.values.some(v=>Number.isFinite(v)));if(reshaped.length===0){return {labels:percentileLabels,series:[]};}return {labels:percentileLabels,series:reshaped};}
+function renderGroupedCorrelationCharts(){const canvases=[...document.querySelectorAll('.grouped-correlation-canvas')];if(canvases.length===0)return;canvases.forEach(canvas=>{const key=canvas.dataset.groupedKey||'';const chart=getGroupedCorrelationChart(key);drawLatencyLine(canvas,chart);});}
+function renderUngroupedCorrelationCharts(){const canvases=[...document.querySelectorAll('.ungrouped-correlation-canvas')];if(canvases.length===0)return;canvases.forEach(canvas=>{const key=canvas.dataset.ungroupedKey||'';const rawChart=getUngroupedCorrelationChart(key);const chart=normalizeUngroupedCorrelationChart(rawChart);drawLatencyLine(canvas,chart);});}
+function initPanePan(){if(!tabsPane)return;let activePointerId=null;let startY=0;let startScroll=0;tabsPane.addEventListener('pointerdown',event=>{if(event.button!==0)return;if(event.target&&event.target.closest&&event.target.closest('button,a,input,textarea,select,label'))return;activePointerId=event.pointerId;startY=event.clientY;startScroll=tabsPane.scrollTop;tabsPane.classList.add('panning');tabsPane.setPointerCapture(event.pointerId);});tabsPane.addEventListener('pointermove',event=>{if(activePointerId!==event.pointerId)return;const delta=event.clientY-startY;tabsPane.scrollTop=startScroll-delta;});const stopPan=event=>{if(activePointerId!==event.pointerId)return;activePointerId=null;tabsPane.classList.remove('panning');};tabsPane.addEventListener('pointerup',stopPan);tabsPane.addEventListener('pointercancel',stopPan);tabsPane.addEventListener('lostpointercapture',()=>{activePointerId=null;tabsPane.classList.remove('panning');});}
+function renderAllCharts(){renderCharts();renderUngroupedCorrelationCharts();renderGroupedCorrelationCharts();}
+const storedReportTheme=(()=>{try{return localStorage.getItem(reportThemeKey);}catch{return null;}})();
+applyReportTheme(storedReportTheme==='dark'?'dark':'light');
+if(reportThemeToggle){reportThemeToggle.addEventListener('click',()=>{const next=document.body.getAttribute('data-theme')==='dark'?'light':'dark';applyReportTheme(next);try{localStorage.setItem(reportThemeKey,next);}catch{}renderAllCharts();});}
+btns.forEach(b=>b.addEventListener('click',()=>show(b.dataset.tab)));
+if(btns.length>0){show(btns[0].dataset.tab);}renderAllCharts();initPanePan();window.addEventListener('resize',renderAllCharts);
+</script>
+</body>
+</html>`;
+    return template
+        .split("\n").join(REPORT_EOL)
+        .split("__LOGO_LIGHT__").join(escapeHtml(getReportLogoLightDataUri()))
+        .split("__LOGO_DARK__").join(escapeHtml(getReportLogoDarkDataUri()))
+        .split("__TEST_SUITE__").join(escapeHtml(reportValue(testInfo, "testSuite", "TestSuite")))
+        .split("__TEST_NAME__").join(escapeHtml(reportValue(testInfo, "testName", "TestName")))
+        .split("__SESSION_ID__").join(escapeHtml(reportValue(testInfo, "sessionId", "SessionId")))
+        .split("__DURATION__").join(escapeHtml(formatDotnetTimeSpan(reportValue(nodeStats, "duration", "Duration", "durationMs", "DurationMs"))))
+        .split("__BUTTONS__").join(buttonsHtml)
+        .split("__SECTIONS__").join(sectionsHtml)
+        .split("__CHART_DATA__").join(chartDataJson)
+        .concat(REPORT_EOL);
+}