@loadstrike/loadstrike-sdk 1.0.20801 → 1.0.21101

package/dist/esm/cluster.js

@@ -1,6 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { EndpointAdapterFactory } from "./transports.js";
 export class LocalClusterCoordinator {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(options = {}) {
         this.options = options;
     }
@@ -59,6 +63,9 @@ export class LocalClusterCoordinator {
         return result;
     }
 }
+/**
+ * Exposes the plan agent scenario assignments operation. Use this when interacting with the SDK through this surface.
+ */
 export function planAgentScenarioAssignments(scenarioNames, agentCount, options = {}) {
     const totalAgents = Math.max(agentCount, 0);
     const assignments = Array.from({ length: totalAgents }, () => []);
@@ -114,10 +121,14 @@ export function planAgentScenarioAssignments(scenarioNames, agentCount, options
     return assignments;
 }
 export class DistributedClusterCoordinator {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(options) {
         this.options = options;
     }
-    async dispatch(assignments) {
+    async dispatch(assignments, buildAgentRunToken) {
         const expected = Math.max(this.options.expectedAgentResults, 0);
         const timeoutMs = Math.max(this.options.commandTimeoutMs ?? 120000, 1);
         const runSubject = this.buildRunSubject();
@@ -139,6 +150,9 @@ export class DistributedClusterCoordinator {
                     targetScenarios: assignments[i] ?? [],
                     replySubject
                 };
+                if (buildAgentRunToken) {
+                    command.agentRunToken = await buildAgentRunToken(command);
+                }
                 await commandProducer.produce({
                     headers: {
                         "x-cluster-command-id": commandId,
@@ -199,6 +213,10 @@ export class DistributedClusterCoordinator {
     }
 }
 export class DistributedClusterAgent {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(options) {
         this.commandConsumer = null;
         this.options = options;
@@ -248,7 +266,13 @@ export class DistributedClusterAgent {
         try {
             let result;
             try {
-                const nodeResult = await execute({ scenarioNames: command.targetScenarios });
+                const nodeResult = await execute({
+                    scenarioNames: command.targetScenarios,
+                    commandId: command.commandId,
+                    agentRunToken: command.agentRunToken,
+                    agentIndex: command.agentIndex,
+                    agentCount: command.agentCount
+                });
                 result = {
                     commandId: command.commandId,
                     agentId: this.options.agentId,
@@ -298,6 +322,7 @@ function parseRunCommand(value) {
         agentIndex: numberOrDefault(value.agentIndex, numberOrDefault(value.AgentIndex, 0)),
         agentCount: numberOrDefault(value.agentCount, numberOrDefault(value.AgentCount, 0)),
         targetScenarios,
+        agentRunToken: stringOrDefault(value.agentRunToken, stringOrDefault(value.AgentRunToken, "")),
         replySubject: stringOrDefault(value.replySubject, stringOrDefault(value.ReplySubject, ""))
     };
 }

package/dist/esm/correlation.js

@@ -1,6 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { createClient } from "redis";
 export class TrackingPayloadBuilder {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor() {
         this.Headers = {};
         this.body = new Uint8Array();
@@ -8,12 +12,24 @@ export class TrackingPayloadBuilder {
     get Body() {
         return new Uint8Array(this.body);
     }
+    /**
+     * Sets the payload body on the builder.
+     * Use this when a tracking payload should be created from raw content.
+     */
     setBody(body) {
         this.body = normalizeTrackingBodyToBytes(body);
     }
+    /**
+     * Sets the payload body on the builder.
+     * Use this when a tracking payload should be created from raw content.
+     */
     SetBody(body) {
         this.setBody(body);
     }
+    /**
+     * Builds the configured payload or helper object.
+     * Use this when all builder inputs are ready to be materialized.
+     */
     build() {
         return createTrackingPayload({
             headers: { ...this.Headers },
@@ -24,6 +40,10 @@ export class TrackingPayloadBuilder {
             jsonConvertSettings: cloneRecord(this.JsonConvertSettings)
         });
     }
+    /**
+     * Builds the configured payload or helper object.
+     * Use this when all builder inputs are ready to be materialized.
+     */
     Build() {
         return this.build();
     }
@@ -41,6 +61,10 @@ export class RedisCorrelationStoreOptions {
     set EntryTtl(value) {
         this.EntryTtlSeconds = value;
     }
+    /**
+     * Exposes the public validate operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     validate() {
         if (!this.ConnectionString.trim()) {
             throw new Error("Redis ConnectionString must be provided.");
@@ -52,6 +76,10 @@ export class RedisCorrelationStoreOptions {
             throw new RangeError("Redis EntryTtl must be greater than zero.");
         }
     }
+    /**
+     * Exposes the public Validate operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     Validate() {
         this.validate();
     }
@@ -60,12 +88,24 @@ export class CorrelationStoreConfiguration {
     constructor() {
         this.Kind = "InMemory";
     }
+    /**
+     * Creates an in-memory correlation store configuration.
+     * Use this when tracking state can stay local to the process.
+     */
     static inMemory() {
         return new CorrelationStoreConfiguration();
     }
+    /**
+     * Creates an in-memory correlation store configuration.
+     * Use this when tracking state can stay local to the process.
+     */
     static InMemory() {
         return CorrelationStoreConfiguration.inMemory();
     }
+    /**
+     * Creates a Redis-backed correlation store configuration.
+     * Use this when tracking state must survive across processes or cluster nodes.
+     */
     static redisStore(options) {
         if (!(options instanceof RedisCorrelationStoreOptions)) {
             throw new TypeError("Redis correlation store options must be provided.");
@@ -75,9 +115,17 @@ export class CorrelationStoreConfiguration {
         configuration.Redis = options;
         return configuration;
     }
+    /**
+     * Creates a Redis-backed correlation store configuration.
+     * Use this when tracking state must survive across processes or cluster nodes.
+     */
     static RedisStore(options) {
         return CorrelationStoreConfiguration.redisStore(options);
     }
+    /**
+     * Exposes the public validate operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     validate() {
         if (this.Kind === "Redis") {
             if (!(this.Redis instanceof RedisCorrelationStoreOptions)) {
@@ -86,6 +134,10 @@ export class CorrelationStoreConfiguration {
             this.Redis.validate();
         }
     }
+    /**
+     * Exposes the public Validate operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     Validate() {
         this.validate();
     }
@@ -97,6 +149,10 @@ export class InMemoryCorrelationStore {
         this.sourceOccurrences = new Map();
         this.destinationOccurrences = new Map();
     }
+    /**
+     * Sets the current gauge value.
+     * Use this when the latest observed value should replace the previous one.
+     */
     set(entry) {
         const normalized = normalizeCorrelationEntry(entry);
         const queue = this.pendingByTrackingId.get(normalized.trackingId) ?? [];
@@ -104,10 +160,18 @@ export class InMemoryCorrelationStore {
         this.pendingByTrackingId.set(normalized.trackingId, queue);
         this.pendingByEventId.set(normalized.eventId ?? "", normalized);
     }
+    /**
+     * Exposes the public get operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     get(trackingId) {
         const queue = this.pendingByTrackingId.get(trackingId);
         return queue && queue.length > 0 ? hydrateCorrelationEntry(queue[0]) : null;
     }
+    /**
+     * Exposes the public delete operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     delete(trackingId) {
         const queue = this.pendingByTrackingId.get(trackingId);
         if (!queue || queue.length === 0) {
@@ -123,6 +187,10 @@ export class InMemoryCorrelationStore {
         }
         this.pendingByTrackingId.set(trackingId, queue);
     }
+    /**
+     * Exposes the public all operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     all() {
         const entries = [];
         for (const queue of this.pendingByTrackingId.values()) {
@@ -132,21 +200,37 @@ export class InMemoryCorrelationStore {
         }
         return entries;
     }
+    /**
+     * Exposes the public collectExpired operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     collectExpired(nowMs = Date.now(), maxCount = 0) {
         void nowMs;
         void maxCount;
         return [];
     }
+    /**
+     * Exposes the public incrementSourceOccurrences operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     incrementSourceOccurrences(trackingId) {
         const next = (this.sourceOccurrences.get(trackingId) ?? 0) + 1;
         this.sourceOccurrences.set(trackingId, next);
         return next;
     }
+    /**
+     * Exposes the public incrementDestinationOccurrences operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     incrementDestinationOccurrences(trackingId) {
         const next = (this.destinationOccurrences.get(trackingId) ?? 0) + 1;
         this.destinationOccurrences.set(trackingId, next);
         return next;
     }
+    /**
+     * Exposes the public registerSource operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     registerSource(trackingId, sourceTimestampUtc) {
         const entry = normalizeCorrelationEntry({
             trackingId,
@@ -159,6 +243,10 @@ export class InMemoryCorrelationStore {
         this.set(entry);
         return entry;
     }
+    /**
+     * Exposes the public tryMatchDestination operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     tryMatchDestination(trackingId, destinationTimestampUtc) {
         const source = this.get(trackingId);
         if (!source) {
@@ -170,6 +258,10 @@ export class InMemoryCorrelationStore {
             destinationTimestampUtc
         });
     }
+    /**
+     * Exposes the public tryExpire operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     tryExpire(eventId) {
         const entry = this.pendingByEventId.get(eventId);
         if (!entry) {
@@ -510,10 +602,18 @@ export class RedisCorrelationStore {
     }
 }
 export class TrackingFieldSelector {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(location, path) {
         this.kind = normalizeTrackingFieldLocation(location);
         this.path = String(path ?? "");
     }
+    /**
+     * Parses a selector or configuration expression.
+     * Use this when a tracking selector should be created from its text form.
+     */
     static parse(value) {
         const normalized = (value ?? "").trim();
         const [kindRaw, ...rest] = normalized.split(":");
@@ -523,9 +623,17 @@ export class TrackingFieldSelector {
         }
         return new TrackingFieldSelector(kindRaw.trim(), path);
     }
+    /**
+     * Parses a selector or configuration expression.
+     * Use this when a tracking selector should be created from its text form.
+     */
     static Parse(value) {
         return TrackingFieldSelector.parse(value);
     }
+    /**
+     * Attempts to parse a selector or configuration expression.
+     * Use this when invalid input should be handled without throwing.
+     */
     static tryParse(value) {
         try {
             return {
@@ -540,6 +648,10 @@ export class TrackingFieldSelector {
             };
         }
     }
+    /**
+     * Attempts to parse a selector or configuration expression.
+     * Use this when invalid input should be handled without throwing.
+     */
     static TryParse(value) {
         return TrackingFieldSelector.tryParse(value);
     }
@@ -549,6 +661,10 @@ export class TrackingFieldSelector {
     get Path() {
         return this.path;
     }
+    /**
+     * Extracts a value from the provided payload.
+     * Use this when a tracking selector should read data from a transport payload.
+     */
     extract(payload) {
         if (this.kind === "header") {
             const headers = payload.headers ?? {};
@@ -578,9 +694,17 @@ export class TrackingFieldSelector {
         }
         return String(current);
     }
+    /**
+     * Exposes the public toString operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     toString() {
         return `${this.kind}:${this.path}`;
     }
+    /**
+     * Exposes the public ToString operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     ToString() {
         return this.toString();
     }
@@ -593,6 +717,10 @@ function normalizeTrackingFieldLocation(location) {
     throw new Error("Tracking field location must be Header or Json.");
 }
 export class CrossPlatformTrackingRuntime {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(options) {
         this.trackingIdDisplayByEventId = new Map();
         this.gatherByDisplayByComparisonKey = new Map();
@@ -810,6 +938,10 @@ export class CrossPlatformTrackingRuntime {
         this.gatherByDisplayByComparisonKey.set(comparisonKey, gatherKey);
         return gatherKey;
     }
+    /**
+     * Exposes the public isTimeoutCountedAsFailure operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     isTimeoutCountedAsFailure() {
         return this.timeoutCountsAsFailure;
     }

package/dist/esm/local.js

@@ -47,6 +47,10 @@ const CI_ENVIRONMENT_VARIABLES = [
     "HEROKU_TEST_RUN_ID"
 ];
 export class LoadStrikeLocalClient {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(options = {}) {
         this.signingKeyCache = new Map();
         assertNoDisableLicenseEnforcementOption(options, "LoadStrikeLocalClient");
@@ -113,6 +117,17 @@ export class LoadStrikeLocalClient {
         const context = asRecord(request.Context);
         const nodeType = normalizeNodeType(pickValue(context, "NodeType", "nodeType"));
         if (nodeType === "agent") {
+            const agentExecutionToken = stringOrDefault(pickValue(context, "AgentExecutionToken", "agentExecutionToken"), "").trim();
+            if (!agentExecutionToken) {
+                throw new Error("Agent node type cannot run directly. Start it from a coordinator session after controller license validation.");
+            }
+            const agentCommandId = stringOrDefault(pickValue(context, "AgentCommandId", "agentCommandId"), "").trim();
+            if (!agentCommandId) {
+                throw new Error("Agent execution is missing the coordinator command identifier.");
+            }
+            const requestedFeatures = collectRequestedFeatures(request);
+            const sessionId = stringOrDefault(pickValue(context, "SessionId", "sessionId"), "").trim();
+            await this.verifySignedAgentExecutionToken(agentExecutionToken, request, requestedFeatures, sessionId, agentCommandId, resolveTargetScenarioNames(context));
             return {};
         }
         const runnerKey = stringOrDefault(context.RunnerKey, "").trim();
@@ -219,6 +234,92 @@ export class LoadStrikeLocalClient {
         enforceEntitlementClaims(parsed.payload, requestedFeatures);
         enforceRuntimePolicyClaims(parsed.payload, request);
     }
+    async createAgentExecutionToken(controllerRunToken, sessionId, commandId, agentIndex, agentCount, targetScenarios) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.licenseValidationTimeoutMs);
+        try {
+            const payload = {
+                ControllerRunToken: controllerRunToken,
+                SessionId: sessionId,
+                CommandId: commandId,
+                AgentIndex: agentIndex,
+                AgentCount: agentCount,
+                TargetScenarios: [...targetScenarios]
+            };
+            const { response, json } = await this.postLicensingRequest("/api/v1/licenses/agent-token", payload, controller.signal);
+            const agentPayload = json;
+            const isValid = pickValue(agentPayload, "IsValid", "isValid");
+            if (!response.ok || isValid !== true) {
+                const details = stringOrDefault(pickValue(agentPayload, "Message", "message"), "No additional details provided.");
+                const denialCode = stringOrDefault(pickValue(agentPayload, "DenialCode", "denialCode"), "unknown_denial");
+                throw new Error(`Agent execution authorization denied. Reason: ${denialCode}. ${details}`);
+            }
+            const agentRunToken = stringOrDefault(pickValue(agentPayload, "AgentRunToken", "agentRunToken"), "").trim();
+            if (!agentRunToken) {
+                throw new Error("Agent execution authorization failed: token is missing.");
+            }
+            return agentRunToken;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async verifySignedAgentExecutionToken(runToken, request, requestedFeatures, sessionId, commandId, targetScenarios) {
+        const parsed = parseJwt(runToken);
+        const keyId = stringOrDefault(parsed.header.kid, "default");
+        const algorithm = stringOrDefault(parsed.header.alg, "RS256").toUpperCase();
+        if (algorithm !== "RS256") {
+            throw new Error("Agent execution authorization failed: invalid token signature.");
+        }
+        const keyRecord = await this.getSigningKey(keyId, algorithm);
+        if (!verifyJwtSignature(runToken, keyRecord, algorithm)) {
+            throw new Error("Agent execution authorization failed: invalid token signature.");
+        }
+        enforceJwtLifetime(parsed.payload);
+        const tokenIssuer = stringOrDefault(parsed.payload.iss, "").trim();
+        if (!keyRecord.issuer || tokenIssuer !== keyRecord.issuer) {
+            throw new Error("Agent execution authorization failed: token issuer does not match.");
+        }
+        const rawAudience = parsed.payload.aud;
+        const tokenAudiences = Array.isArray(rawAudience)
+            ? rawAudience.map((entry) => stringOrDefault(entry, "").trim()).filter((entry) => entry.length > 0)
+            : stringOrDefault(rawAudience, "").trim()
+                ? [stringOrDefault(rawAudience, "").trim()]
+                : [];
+        if (!keyRecord.audience || !tokenAudiences.includes(keyRecord.audience)) {
+            throw new Error("Agent execution authorization failed: token audience does not match.");
+        }
+        const tokenKind = stringOrDefault(parsed.payload.token_kind, "").trim();
+        if (tokenKind !== "agent_execution") {
+            throw new Error("Agent execution authorization failed: token kind is invalid.");
+        }
+        const tokenNodeType = stringOrDefault(parsed.payload.node_type, "").trim().toLowerCase();
+        if (tokenNodeType !== "agent") {
+            throw new Error("Agent execution authorization failed: token node type is invalid.");
+        }
+        const tokenSessionId = stringOrDefault(parsed.payload.session_id, "").trim();
+        if (tokenSessionId !== sessionId) {
+            throw new Error("Agent execution authorization failed: session id does not match.");
+        }
+        const tokenCommandId = stringOrDefault(parsed.payload.command_id, "").trim();
+        if (tokenCommandId !== commandId) {
+            throw new Error("Agent execution authorization failed: command id does not match.");
+        }
+        const tokenTargetScenarios = collectClaimStrings(parsed.payload, "target_scenario")
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0)
+            .sort();
+        const expectedTargetScenarios = [...targetScenarios]
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0)
+            .sort();
+        if (tokenTargetScenarios.length !== expectedTargetScenarios.length
+            || tokenTargetScenarios.some((value, index) => value !== expectedTargetScenarios[index])) {
+            throw new Error("Agent execution authorization failed: target scenarios do not match.");
+        }
+        enforceEntitlementClaims(parsed.payload, requestedFeatures);
+        enforceRuntimePolicyClaims(parsed.payload, request);
+    }
     async getSigningKey(keyId, algorithm) {
         const nowMs = Date.now();
         const normalizedKeyId = stringOrDefault(keyId, "default").trim() || "default";
@@ -400,6 +501,7 @@ function generateSessionId() {
 function collectRequestedFeatures(request) {
     const context = asRecord(request.Context);
     const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    const nodeType = normalizeNodeType(pickValue(context, "NodeType", "nodeType"));
     const features = new Set([
         "core.runtime",
         "reporting.formats.standard"
@@ -413,7 +515,9 @@ function collectRequestedFeatures(request) {
     const hasAdvancedTargeting = normalizeStringArray(pickValue(context, "AgentTargetScenarios", "agentTargetScenarios")).length > 0
         || normalizeStringArray(pickValue(context, "CoordinatorTargetScenarios", "coordinatorTargetScenarios")).length > 0
         || resolveTimeoutSeconds(context, "ClusterCommandTimeoutSeconds", "clusterCommandTimeoutSeconds", "ClusterCommandTimeoutMs", "clusterCommandTimeoutMs", 120) !== 120;
-    if (hasAdvancedTargeting) {
+    // Agent child contexts carry coordinator-assigned target slices. That internal
+    // state must not force the advanced targeting entitlement a second time.
+    if (hasAdvancedTargeting && nodeType !== "agent") {
         features.add("cluster.targeting_and_tuning.advanced");
     }
     if (countCustomWorkerPlugins(context) > 0) {
@@ -1850,13 +1954,16 @@ function toContractNodeType(value) {
     }
 }
 function countTargetedScenarios(context) {
-    const values = [
-        ...normalizeStringArray(pickValue(context, "TargetScenarios", "targetScenarios")),
-        ...normalizeStringArray(pickValue(context, "AgentTargetScenarios", "agentTargetScenarios")),
-        ...normalizeStringArray(pickValue(context, "CoordinatorTargetScenarios", "coordinatorTargetScenarios"))
-    ];
+    const values = resolveTargetScenarioNames(context);
     return new Set(values.map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0)).size;
 }
+function resolveTargetScenarioNames(context) {
+    return [...new Set([
+            ...normalizeStringArray(pickValue(context, "TargetScenarios", "targetScenarios")),
+            ...normalizeStringArray(pickValue(context, "AgentTargetScenarios", "agentTargetScenarios")),
+            ...normalizeStringArray(pickValue(context, "CoordinatorTargetScenarios", "coordinatorTargetScenarios"))
+        ])];
+}
 function countCustomWorkerPlugins(context) {
     const workerPlugins = asList(pickValue(context, "WorkerPlugins", "workerPlugins"));
     let count = 0;

package/dist/esm/reporting.js

@@ -1031,6 +1031,9 @@ function buildDotnetHtmlTabs(nodeStats) {
     }
     return tabs;
 }
+/**
+ * Exposes the build dotnet txt report operation. Use this when interacting with the SDK through this surface.
+ */
 export function buildDotnetTxtReport(nodeStats) {
     const scenarios = sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"));
     const testInfo = reportObject(nodeStats, "testInfo", "TestInfo");
@@ -1077,6 +1080,9 @@ export function buildDotnetTxtReport(nodeStats) {
     }
     return reportLines(lines);
 }
+/**
+ * Exposes the build dotnet csv report operation. Use this when interacting with the SDK through this surface.
+ */
 export function buildDotnetCsvReport(nodeStats) {
     const lines = ["ScenarioName,Requests,Ok,Fail,DurationSeconds,Rps"];
     for (const scenario of sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"))) {
@@ -1086,6 +1092,9 @@ export function buildDotnetCsvReport(nodeStats) {
     }
     return reportLines(lines);
 }
+/**
+ * Exposes the build dotnet markdown report operation. Use this when interacting with the SDK through this surface.
+ */
 export function buildDotnetMarkdownReport(nodeStats) {
     const scenarios = sortBySortIndex(reportArray(nodeStats, "scenarioStats", "ScenarioStats"));
     const testInfo = reportObject(nodeStats, "testInfo", "TestInfo");
@@ -1125,6 +1134,9 @@ export function buildDotnetMarkdownReport(nodeStats) {
     }
     return reportLines(lines);
 }
+/**
+ * Exposes the build dotnet html report operation. Use this when interacting with the SDK through this surface.
+ */
 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("");