@loadstrike/loadstrike-sdk 1.0.30201 → 1.0.31001

package/dist/esm/local.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _LoadStrikeLocalClient_licensingApiBaseUrl, _LoadStrikeLocalClient_signingKeyCache;
+var _LoadStrikeLocalClient_licensingApiBaseUrl, _LoadStrikeLocalClient_signingKeyCache, _LoadStrikeLocalClient_heartbeatDrains;
 import os from "node:os";
 import * as fs from "node:fs";
 import * as childProcess from "node:child_process";
@@ -70,6 +70,7 @@ export class LoadStrikeLocalClient {
     constructor(options = {}) {
         _LoadStrikeLocalClient_licensingApiBaseUrl.set(this, void 0);
         _LoadStrikeLocalClient_signingKeyCache.set(this, new Map());
+        _LoadStrikeLocalClient_heartbeatDrains.set(this, new WeakMap());
         assertNoDisableLicenseEnforcementOption(options, "LoadStrikeLocalClient");
         __classPrivateFieldSet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, resolveLicensingApiBaseUrl(), "f");
         this.licenseValidationTimeoutMs = normalizeTimeoutMs(options.licenseValidationTimeoutMs);
@@ -189,28 +190,59 @@ export class LoadStrikeLocalClient {
             }
             await this.verifySignedRunToken(runToken, request, requestedFeatures, runnerKey, sessionId, computedDeviceHash);
             const heartbeatIntervalSeconds = Math.max(asInt(pickValue(json, "HeartbeatIntervalSeconds", "heartbeatIntervalSeconds")), 1);
-            const heartbeatTimer = setInterval(() => {
-                void this.sendRunTokenHeartbeat({
-                    runToken,
-                    sessionId,
-                    deviceHash: computedDeviceHash,
-                    machineName,
-                    environmentClassification
-                }).catch(() => {
-                    // Best-effort heartbeat: server-side lease expiration is authoritative.
-                });
-            }, heartbeatIntervalSeconds * 1000);
-            if (typeof heartbeatTimer.unref === "function") {
-                heartbeatTimer.unref();
-            }
-            return {
+            const session = {
                 runToken,
                 sessionId,
                 deviceHash: computedDeviceHash,
                 machineName,
-                environmentClassification,
-                heartbeatTimer
+                environmentClassification
             };
+            let heartbeatInFlight = false;
+            const runHeartbeat = async () => {
+                heartbeatInFlight = true;
+                try {
+                    const currentRunToken = stringOrDefault(session.runToken, "").trim();
+                    if (!currentRunToken) {
+                        return;
+                    }
+                    const refreshedRunToken = await this.sendRunTokenHeartbeat({
+                        runToken: currentRunToken,
+                        sessionId,
+                        deviceHash: computedDeviceHash,
+                        machineName,
+                        environmentClassification
+                    });
+                    if (!refreshedRunToken) {
+                        return;
+                    }
+                    try {
+                        await this.verifySignedRunToken(refreshedRunToken, request, requestedFeatures, runnerKey, sessionId, computedDeviceHash);
+                    }
+                    catch {
+                        return;
+                    }
+                    session.runToken = refreshedRunToken;
+                }
+                catch {
+                    // Best-effort heartbeat: server-side lease expiration is authoritative.
+                }
+                finally {
+                    heartbeatInFlight = false;
+                }
+            };
+            let currentHeartbeat = Promise.resolve();
+            const heartbeatTimer = setInterval(() => {
+                if (!heartbeatInFlight) {
+                    currentHeartbeat = runHeartbeat();
+                }
+                return currentHeartbeat;
+            }, heartbeatIntervalSeconds * 1000);
+            if (typeof heartbeatTimer.unref === "function") {
+                heartbeatTimer.unref();
+            }
+            session.heartbeatTimer = heartbeatTimer;
+            __classPrivateFieldGet(this, _LoadStrikeLocalClient_heartbeatDrains, "f").set(session, () => currentHeartbeat);
+            return session;
         }
         finally {
             clearTimeout(timer);
@@ -394,18 +426,35 @@ export class LoadStrikeLocalClient {
         const timer = controller
             ? setTimeout(() => controller.abort(), this.licenseValidationTimeoutMs)
             : null;
-        const { response } = await this.postLicensingRequest("/api/v1/licenses/heartbeat", heartbeatPayload, signal ?? controller.signal);
+        const { response, json } = await this.postLicensingRequest("/api/v1/licenses/heartbeat", heartbeatPayload, signal ?? controller.signal);
         if (timer) {
             clearTimeout(timer);
         }
         if (!response.ok) {
             throw new Error(`Runner key validation denied. DenialCode=run_token_heartbeat_failed, Message=Run token heartbeat failed with status ${response.status}.`);
         }
+        if (pickValue(json ?? {}, "IsValid", "isValid") !== true) {
+            return undefined;
+        }
+        const refreshedRunToken = stringOrDefault(pickValue(json ?? {}, "RunToken", "runToken"), "").trim();
+        return refreshedRunToken || undefined;
     }
     async stopLicenseLeaseIfRequired(session, _request) {
         if (session.heartbeatTimer) {
             clearInterval(session.heartbeatTimer);
         }
+        const heartbeatDrain = __classPrivateFieldGet(this, _LoadStrikeLocalClient_heartbeatDrains, "f").get(session);
+        if (heartbeatDrain) {
+            try {
+                await heartbeatDrain();
+            }
+            catch {
+                // Heartbeats are best-effort and retain the last fully verified token.
+            }
+            finally {
+                __classPrivateFieldGet(this, _LoadStrikeLocalClient_heartbeatDrains, "f").delete(session);
+            }
+        }
         if (!session.runToken) {
             return;
         }
@@ -463,7 +512,7 @@ export class LoadStrikeLocalClient {
         return { response, json };
     }
 }
-_LoadStrikeLocalClient_licensingApiBaseUrl = new WeakMap(), _LoadStrikeLocalClient_signingKeyCache = new WeakMap();
+_LoadStrikeLocalClient_licensingApiBaseUrl = new WeakMap(), _LoadStrikeLocalClient_signingKeyCache = new WeakMap(), _LoadStrikeLocalClient_heartbeatDrains = new WeakMap();
 function assertNoDisableLicenseEnforcementOption(value, source) {
     if (value == null || typeof value !== "object" || Array.isArray(value)) {
         return;
@@ -1329,9 +1378,20 @@ function readTrackingId(payload, selector) {
             return null;
         }
         let current = body;
-        for (const segment of path.split(".").filter(Boolean)) {
+        let segments;
+        try {
+            segments = safeJsonPathSegments(path);
+        }
+        catch {
+            return null;
+        }
+        for (const segment of segments) {
             if (current && typeof current === "object" && !Array.isArray(current)) {
-                current = current[segment];
+                const record = current;
+                if (!Object.prototype.hasOwnProperty.call(record, segment)) {
+                    return null;
+                }
+                current = record[segment];
             }
             else {
                 return null;
@@ -1364,23 +1424,57 @@ function readOptionalTrackingSelectorValue(value) {
     return undefined;
 }
 function setJsonPathValue(body, path, value) {
-    const target = body && typeof body === "object" && !Array.isArray(body)
-        ? { ...body }
-        : {};
-    const segments = path.split(".").filter(Boolean);
+    const target = cloneJsonRecord(body);
+    const segments = safeJsonPathSegments(path);
     if (!segments.length) {
         return target;
     }
     let current = target;
     for (let i = 0; i < segments.length - 1; i += 1) {
         const segment = segments[i];
-        const next = current[segment];
+        const next = readOwnJsonProperty(current, segment);
+        let child;
         if (!next || typeof next !== "object" || Array.isArray(next)) {
-            current[segment] = {};
+            child = {};
         }
-        current = current[segment];
+        else {
+            child = cloneJsonRecord(next);
+        }
+        defineJsonProperty(current, segment, child);
+        current = child;
+    }
+    defineJsonProperty(current, segments[segments.length - 1], value);
+    return target;
+}
+const FORBIDDEN_JSON_PATH_SEGMENTS = new Set(["__proto__", "prototype", "constructor"]);
+function safeJsonPathSegments(path) {
+    const segments = path.split(".").filter(Boolean);
+    const forbidden = segments.find((segment) => FORBIDDEN_JSON_PATH_SEGMENTS.has(segment));
+    if (forbidden) {
+        throw new Error(`Tracking selector contains forbidden JSON path segment '${forbidden}'.`);
+    }
+    return segments;
+}
+function defineJsonProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+    });
+}
+function readOwnJsonProperty(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function cloneJsonRecord(value) {
+    const target = {};
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return target;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        defineJsonProperty(target, key, entry);
     }
-    current[segments[segments.length - 1]] = value;
     return target;
 }
 function mapCorrelationStore(tracking, runNamespace) {
@@ -1827,6 +1921,10 @@ function isRuntimeReportingSink(value) {
         "SaveRealtimeMetrics",
         "saveRunResult",
         "SaveRunResult",
+        "saveIterationBatch",
+        "SaveIterationBatch",
+        "completeIterationObservationStream",
+        "CompleteIterationObservationStream",
         "stop",
         "Stop"
     ].some((name) => typeof record[name] === "function");

package/dist/esm/reporting.js

@@ -38,8 +38,12 @@ function reportValue(source, ...keys) {
     }
     const record = source;
     for (const key of keys) {
-        if (record[key] !== undefined && record[key] !== null) {
-            return record[key];
+        const descriptor = Object.getOwnPropertyDescriptor(record, key);
+        if (descriptor
+            && "value" in descriptor
+            && descriptor.value !== undefined
+            && descriptor.value !== null) {
+            return descriptor.value;
         }
     }
     return undefined;
@@ -132,6 +136,26 @@ function asFloat(value) {
     const parsed = Number.parseFloat(asString(value));
     return Number.isFinite(parsed) ? parsed : 0;
 }
+function combinedMeasurement(source) {
+    const all = reportValue(source, "allMeasurement", "AllMeasurement");
+    if (all && typeof all === "object" && !Array.isArray(all)) {
+        return all;
+    }
+    const ok = reportObject(source, "ok", "Ok");
+    const fail = reportObject(source, "fail", "Fail");
+    const okCount = asInt(reportValue(reportObject(ok, "request", "Request"), "count", "Count"));
+    const failCount = asInt(reportValue(reportObject(fail, "request", "Request"), "count", "Count"));
+    if (okCount === 0) {
+        return fail;
+    }
+    return failCount === 0 ? ok : undefined;
+}
+function formatCombinedLatency(source, ...keys) {
+    const measurement = combinedMeasurement(source);
+    return measurement
+        ? formatReportNumber(reportValue(reportObject(measurement, "latency", "Latency"), ...keys))
+        : "n/a";
+}
 function asBool(value) {
     if (typeof value === "boolean") {
         return value;
@@ -302,7 +326,22 @@ function formatDotnetDateTime(value) {
     return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${fraction}Z`;
 }
 function escapeJsonForHtmlScript(value) {
-    return value.split("</").join("<\\/").split("<!--").join("<\\!--");
+    return value.replace(/[<>&\u2028\u2029]/g, (character) => {
+        switch (character) {
+            case "<":
+                return "\\u003c";
+            case ">":
+                return "\\u003e";
+            case "&":
+                return "\\u0026";
+            case "\u2028":
+                return "\\u2028";
+            case "\u2029":
+                return "\\u2029";
+            default:
+                return character;
+        }
+    });
 }
 function buildReportLogoDataUri(resourceName) {
     const cached = REPORT_LOGO_CACHE.get(resourceName);
@@ -747,8 +786,8 @@ function buildDotnetScenarioRows(nodeStats) {
             FAIL: reportFailCountValue(scenario),
             Duration: formatDotnetTimeSpan(reportDurationValue(scenario)),
             RPS: formatReportNumber(reportDurationSeconds(reportDurationValue(scenario)) <= 0 ? 0 : requestCount / reportDurationSeconds(reportDurationValue(scenario))),
-            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")))),
+            LatencyP95Ms: formatCombinedLatency(scenario, "percent95", "Percent95"),
+            LatencyP99Ms: formatCombinedLatency(scenario, "percent99", "Percent99"),
             CurrentOperation: asString(reportValue(scenario, "currentOperation", "CurrentOperation"))
         };
     });
@@ -765,8 +804,8 @@ function buildDotnetStepRows(nodeStats) {
                 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"))))
+                LatencyMeanMs: formatCombinedLatency(step, "meanMs", "MeanMs"),
+                P95LatencyMs: formatCombinedLatency(step, "percent95", "Percent95")
             });
         }
     }
@@ -776,6 +815,10 @@ function buildDotnetScenarioMeasurementRows(nodeStats) {
     const rows = [];
     for (const scenario of reportScenarios(nodeStats)) {
         const scenarioName = asString(reportValue(scenario, "scenarioName", "ScenarioName"));
+        const allMeasurement = reportValue(scenario, "allMeasurement", "AllMeasurement");
+        if (allMeasurement && typeof allMeasurement === "object" && !Array.isArray(allMeasurement)) {
+            pushMeasurementRowIfData(rows, "Scenario", scenarioName, "", "ALL", allMeasurement);
+        }
         pushMeasurementRowIfData(rows, "Scenario", scenarioName, "", "OK", reportObject(scenario, "ok", "Ok"));
         pushMeasurementRowIfData(rows, "Scenario", scenarioName, "", "FAIL", reportObject(scenario, "fail", "Fail"));
     }
@@ -787,6 +830,10 @@ function buildDotnetStepMeasurementRows(nodeStats) {
         const scenarioName = asString(reportValue(scenario, "scenarioName", "ScenarioName"));
         for (const step of reportSteps(scenario)) {
             const stepName = asString(reportValue(step, "stepName", "StepName"));
+            const allMeasurement = reportValue(step, "allMeasurement", "AllMeasurement");
+            if (allMeasurement && typeof allMeasurement === "object" && !Array.isArray(allMeasurement)) {
+                pushMeasurementRowIfData(rows, "Step", scenarioName, stepName, "ALL", allMeasurement);
+            }
             pushMeasurementRowIfData(rows, "Step", scenarioName, stepName, "OK", reportObject(step, "ok", "Ok"));
             pushMeasurementRowIfData(rows, "Step", scenarioName, stepName, "FAIL", reportObject(step, "fail", "Fail"));
         }
@@ -867,6 +914,9 @@ function buildDotnetStatusCodeClassChart(scenarios) {
 }
 function buildDotnetChartData(nodeStats) {
     const scenarios = reportScenarios(nodeStats);
+    const combinedScenarios = scenarios
+        .map((scenario) => ({ scenario, measurement: combinedMeasurement(scenario) }))
+        .filter((item) => item.measurement !== undefined);
     return {
         overallOutcome: [
             { label: "OK", value: reportTotalOkCount(nodeStats, scenarios), color: "#18a957" },
@@ -877,9 +927,9 @@ function buildDotnetChartData(nodeStats) {
             value: reportRequestCountValue(scenario),
             color: "#3b82f6"
         })),
-        scenarioP95Latency: scenarios.map((scenario) => ({
+        scenarioP95Latency: combinedScenarios.map(({ scenario, measurement }) => ({
             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"))),
+            value: asFloat(reportValue(reportObject(measurement, "latency", "Latency"), "percent95", "Percent95")),
             color: "#8b5cf6"
         })),
         scenarioRps: scenarios.map((scenario) => ({
@@ -903,12 +953,12 @@ function buildDotnetChartData(nodeStats) {
         })),
         statusCodeClasses: buildDotnetStatusCodeClassChart(scenarios),
         scenarioLatencyTrend: {
-            labels: scenarios.map((scenario) => asString(reportValue(scenario, "scenarioName", "ScenarioName"))),
+            labels: combinedScenarios.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")))) }
+                { name: "P50", color: "#38bdf8", values: combinedScenarios.map(({ measurement }) => asFloat(reportValue(reportObject(measurement, "latency", "Latency"), "percent50", "Percent50"))) },
+                { name: "P75", color: "#22c55e", values: combinedScenarios.map(({ measurement }) => asFloat(reportValue(reportObject(measurement, "latency", "Latency"), "percent75", "Percent75"))) },
+                { name: "P95", color: "#f59e0b", values: combinedScenarios.map(({ measurement }) => asFloat(reportValue(reportObject(measurement, "latency", "Latency"), "percent95", "Percent95"))) },
+                { name: "P99", color: "#f43f5e", values: combinedScenarios.map(({ measurement }) => asFloat(reportValue(reportObject(measurement, "latency", "Latency"), "percent99", "Percent99"))) }
             ]
         }
     };
@@ -1053,6 +1103,82 @@ function buildDotnetThresholdHtml(nodeStats) {
 function buildDotnetMetricHtml(nodeStats) {
     return buildDotnetTableHtml(buildDotnetMetricRows(nodeStats));
 }
+function buildDotnetGeneratorDeliveryHtml(nodeStats) {
+    const warnings = reportArray(nodeStats, "generatorWarnings", "GeneratorWarnings");
+    const stats = reportObject(nodeStats, "schedulerStats", "SchedulerStats");
+    const topLevelSegments = reportArray(nodeStats, "schedulerSegments", "SchedulerSegments");
+    const segments = topLevelSegments.length > 0
+        ? topLevelSegments
+        : reportArray(stats, "segments", "Segments");
+    const observationStats = reportObject(nodeStats, "observationDeliveryStats", "ObservationDeliveryStats");
+    const reportingCompleteValue = reportValue(nodeStats, "reportingComplete", "ReportingComplete");
+    const reportingComplete = reportingCompleteValue == null
+        ? "N/A"
+        : asBool(reportingCompleteValue) ? "Yes" : "No";
+    const parts = [];
+    appendReportLine(parts, "<div class=\"card\">");
+    appendReportLine(parts, "<h2>Generator Delivery</h2>");
+    appendReportLine(parts, "<p>Application failures remain separate from generator and reporting warnings. Dropped arrivals, unavailable worker slots, and raw observation loss are not synthetic SUT errors.</p>");
+    appendReportLine(parts, "<div class=\"card-grid\">");
+    for (const [label, value] of [
+        ["Configured Max In Flight", asInt(reportValue(stats, "configuredMaxInFlight", "ConfiguredMaxInFlight"))],
+        ["Observed Max In Flight", asInt(reportValue(stats, "maxInFlightObserved", "MaxInFlightObserved"))],
+        ["Current In Flight", asInt(reportValue(stats, "currentInFlight", "CurrentInFlight"))],
+        ["Observation Captured", asString(reportValue(observationStats, "capturedCount64", "CapturedCount64")) || "0"],
+        ["Observation Delivered", asString(reportValue(observationStats, "deliveredCount64", "DeliveredCount64")) || "0"],
+        ["Observation Buffer Drops", asString(reportValue(observationStats, "droppedBufferCount64", "DroppedBufferCount64")) || "0"],
+        ["Observation Sink Drops", asString(reportValue(observationStats, "droppedSinkCount64", "DroppedSinkCount64")) || "0"],
+        ["Reporting Complete", reportingComplete],
+        ["Warning Groups", warnings.length]
+    ]) {
+        appendReportLine(parts, `<div class="stat-card"><div class="stat-label">${escapeHtml(label)}</div><div class="stat-value">${escapeHtml(value)}</div></div>`);
+    }
+    appendReportLine(parts, "</div></div>");
+    if (warnings.length) {
+        appendReportLine(parts, "<div class=\"card\"><h2>Generator Warnings</h2>");
+        parts.push(buildDotnetTableHtml(warnings, false));
+        appendReportLine(parts, "</div>");
+    }
+    if (segments.length) {
+        const rows = segments.map((segment) => ({
+            Scenario: asString(reportValue(segment, "scenarioName", "ScenarioName")),
+            Simulation: asString(reportValue(segment, "kind", "Kind")),
+            Shard: `${asInt(reportValue(segment, "shardIndex", "ShardIndex"))}/${Math.max(asInt(reportValue(segment, "shardCount", "ShardCount")), 1)}`,
+            Planned: asString(reportValue(segment, "plannedIterations64", "PlannedIterations64")),
+            Due: asString(reportValue(segment, "dueIterations64", "DueIterations64")),
+            Started: asString(reportValue(segment, "startedIterations64", "StartedIterations64")),
+            Completed: asString(reportValue(segment, "completedIterations64", "CompletedIterations64")),
+            Dropped: asString(reportValue(segment, "droppedIterations64", "DroppedIterations64")),
+            Unreached: asString(reportValue(segment, "unreachedIterations64", "UnreachedIterations64")),
+            "Unavailable Workers": asString(reportValue(segment, "unavailableWorkerSlots64", "UnavailableWorkerSlots64")),
+            "Delivery %": formatReportNumber(reportValue(segment, "deliveryPercent", "DeliveryPercent")),
+            "Accounting Complete": Boolean(reportValue(segment, "accountingComplete", "AccountingComplete"))
+        }));
+        appendReportLine(parts, "<div class=\"card\"><h2>Scheduler Segments</h2>");
+        parts.push(buildDotnetTableHtml(rows, false));
+        appendReportLine(parts, "</div>");
+    }
+    return parts.join("");
+}
+function hasDotnetGeneratorDeliveryData(nodeStats) {
+    const schedulerStats = reportObject(nodeStats, "schedulerStats", "SchedulerStats");
+    const observationStats = reportObject(nodeStats, "observationDeliveryStats", "ObservationDeliveryStats");
+    const hasNonZeroDecimal = (value) => {
+        const text = asString(value);
+        return text.trim().length > 0 && text !== "0";
+    };
+    return reportArray(nodeStats, "generatorWarnings", "GeneratorWarnings").length > 0
+        || reportArray(nodeStats, "schedulerSegments", "SchedulerSegments").length > 0
+        || reportArray(schedulerStats, "segments", "Segments").length > 0
+        || asInt(reportValue(schedulerStats, "configuredMaxInFlight", "ConfiguredMaxInFlight")) > 0
+        || asInt(reportValue(schedulerStats, "maxInFlightObserved", "MaxInFlightObserved")) > 0
+        || asInt(reportValue(schedulerStats, "currentInFlight", "CurrentInFlight")) > 0
+        || reportValue(nodeStats, "reportingComplete", "ReportingComplete") === false
+        || hasNonZeroDecimal(reportValue(observationStats, "capturedCount64", "CapturedCount64"))
+        || hasNonZeroDecimal(reportValue(observationStats, "deliveredCount64", "DeliveredCount64"))
+        || hasNonZeroDecimal(reportValue(observationStats, "droppedBufferCount64", "DroppedBufferCount64"))
+        || hasNonZeroDecimal(reportValue(observationStats, "droppedSinkCount64", "DroppedSinkCount64"));
+}
 function buildDotnetGroupedCorrelationSummaryHtml(rows, groupedChartKey) {
     const parts = [];
     const payloads = buildGroupedCorrelationChartPayloads(rows);
@@ -1129,6 +1255,9 @@ function buildDotnetHtmlTabs(nodeStats) {
     if (metricRows.length) {
         tabs.push(["metrics", "Metrics", buildDotnetTableHtml(metricRows)]);
     }
+    if (hasDotnetGeneratorDeliveryData(nodeStats)) {
+        tabs.push(["generator-delivery", "Generator Delivery", buildDotnetGeneratorDeliveryHtml(nodeStats)]);
+    }
     for (const plugin of reportArray(nodeStats, "pluginsData", "PluginsData")) {
         const pluginName = asString(reportValue(plugin, "pluginName", "PluginName"));
         const hints = buildDotnetPluginHints(plugin);
@@ -1162,7 +1291,7 @@ function buildDotnetHtmlTabs(nodeStats) {
                 body = buildDotnetGroupedCorrelationSummaryHtml(bodyRows, `grouped-correlation-${tabs.length}`);
             }
             else if (lowerPlugin.includes("correlation") && lowerTable.includes("ungrouped correlation rows")) {
-                title = "Ungrouped Corelation Summary";
+                title = "Ungrouped Correlation Summary";
                 body = buildDotnetUngroupedCorrelationSummaryHtml(bodyRows, `ungrouped-correlation-${tabs.length}`);
             }
             tabs.push([`plugin-${tabs.length}`, title, `${hints}${body}`]);
@@ -1278,9 +1407,9 @@ export function buildDotnetMarkdownReport(nodeStats) {
  */
 export 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 buttonsHtml = tabs.map(([tabId, title]) => `<button class="tab-btn" data-tab="${escapeHtml(tabId)}">${escapeHtml(title)}</button>${REPORT_EOL}`).join("");
+    const sectionsHtml = tabs.map(([tabId, , html]) => `<section id="${escapeHtml(tabId)}" class="tab">${html}</section>${REPORT_EOL}`).join("");
+    const chartDataJson = escapeJsonForHtmlScript(JSON.stringify(buildDotnetChartData(nodeStats)));
     const testInfo = reportObject(nodeStats, "testInfo", "TestInfo");
     const template = `<!doctype html>
 <html lang="en">
@@ -1372,7 +1501,7 @@ 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 setupCanvas(canvas){const dpr=window.devicePixelRatio||1;const rect=canvas.getBoundingClientRect();const w=Math.max(1,Math.round(rect.width||canvas.clientWidth||320));const h=Math.max(1,Math.round(rect.height||canvas.clientHeight||220));canvas.width=Math.max(1,Math.round(w*dpr));canvas.height=Math.max(1,Math.round(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;}}