@loadstrike/loadstrike-sdk 1.0.20801 → 1.0.21101

package/dist/esm/runtime.js

@@ -42,14 +42,26 @@ export const LoadStrikeOperationType = {
     Error: "Error"
 };
 export class LoadStrikePluginDataTable {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(tableName, headers = [], rows = []) {
         this.tableName = requireNonEmpty(tableName, "Table name must be provided.");
         this.headers = [...headers];
         this.rows = rows.map((row) => ({ ...row }));
     }
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static create(tableName) {
         return new LoadStrikePluginDataTable(tableName);
     }
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static Create(tableName) {
         return LoadStrikePluginDataTable.create(tableName);
     }
@@ -64,14 +76,26 @@ export class LoadStrikePluginDataTable {
     }
 }
 export class LoadStrikePluginData {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(pluginName, tables = [], hints = []) {
         this.pluginName = requireNonEmpty(pluginName, "Plugin name must be provided.");
         this.tables = tables.map((table) => new LoadStrikePluginDataTable(table.tableName, table.headers, table.rows));
         this.hints = [...hints];
     }
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static create(pluginName) {
         return new LoadStrikePluginData(pluginName);
     }
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static Create(pluginName) {
         return LoadStrikePluginData.create(pluginName);
     }
@@ -96,6 +120,10 @@ class MeasurementAccumulator {
     get Count() {
         return this.count;
     }
+    /**
+     * Exposes the public record operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     record(reply, observedLatencyMs) {
         const latencyMs = resolveRecordedLatency(reply.customLatencyMs, observedLatencyMs);
         const sizeBytes = Math.max(toNumber(reply.sizeBytes), 0);
@@ -118,6 +146,10 @@ class MeasurementAccumulator {
             count: 1
         });
     }
+    /**
+     * Builds the configured payload or helper object.
+     * Use this when all builder inputs are ready to be materialized.
+     */
     build(allRequestCount, durationMs) {
         const count = this.count;
         const totalDurationMs = Math.max(durationMs, 0);
@@ -176,6 +208,10 @@ class StepStatsAccumulator {
         this.ok = new MeasurementAccumulator();
         this.fail = new MeasurementAccumulator();
     }
+    /**
+     * Exposes the public record operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     record(reply, observedLatencyMs) {
         if (reply.isSuccess) {
             this.ok.record(reply, observedLatencyMs);
@@ -183,6 +219,10 @@ class StepStatsAccumulator {
         }
         this.fail.record(reply, observedLatencyMs);
     }
+    /**
+     * Builds the configured payload or helper object.
+     * Use this when all builder inputs are ready to be materialized.
+     */
     build(allScenarioRequestCount, durationMs) {
         const ok = this.ok.build(allScenarioRequestCount, durationMs);
         const fail = this.fail.build(allScenarioRequestCount, durationMs);
@@ -222,18 +262,34 @@ class ScenarioStatsAccumulator {
         this.loadSimulationStats = { simulationName: "", value: 0 };
         this.currentOperation = "None";
     }
+    /**
+     * Exposes the public setLoadSimulation operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     setLoadSimulation(simulationName, value) {
         this.loadSimulationStats = {
             simulationName,
             value
         };
     }
+    /**
+     * Exposes the public setCurrentOperation operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     setCurrentOperation(operation) {
         this.currentOperation = operation;
     }
+    /**
+     * Returns current operation.
+     * Use this when current operation is required for branching, logging, or assertions.
+     */
     getCurrentOperation() {
         return this.currentOperation;
     }
+    /**
+     * Exposes the public recordScenario operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     recordScenario(reply, observedLatencyMs) {
         if (reply.isSuccess) {
             this.ok.record(reply, observedLatencyMs);
@@ -241,6 +297,10 @@ class ScenarioStatsAccumulator {
         }
         this.fail.record(reply, observedLatencyMs);
     }
+    /**
+     * Exposes the public recordStep operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     recordStep(stepName, reply, observedLatencyMs) {
         const existing = this.steps.get(stepName);
         const step = existing ?? new StepStatsAccumulator(this.scenarioName, stepName, this.nextStepSortIndex += 1);
@@ -249,6 +309,10 @@ class ScenarioStatsAccumulator {
         }
         step.record(reply, observedLatencyMs);
     }
+    /**
+     * Builds the configured payload or helper object.
+     * Use this when all builder inputs are ready to be materialized.
+     */
     build(durationMs) {
         const totalRequests = this.ok.Count + this.fail.Count;
         const ok = this.ok.build(totalRequests, durationMs);
@@ -293,6 +357,10 @@ class ScenarioStatsAccumulator {
     }
 }
 export class LoadStrikeResponse {
+    /**
+     * Creates a successful reply.
+     * Use this when a step or scenario completed successfully and should report a success response.
+     */
     static ok(...args) {
         const normalized = normalizeSuccessResponseCall(args);
         const reply = {
@@ -305,6 +373,10 @@ export class LoadStrikeResponse {
         };
         return attachReplyProjection(reply);
     }
+    /**
+     * Creates a successful reply.
+     * Use this when a step or scenario completed successfully and should report a success response.
+     */
     static Ok(...args) {
         return LoadStrikeResponse.ok(...args);
     }
@@ -314,6 +386,10 @@ export class LoadStrikeResponse {
     static OkWithPayload(payload, statusCode = "200", sizeBytesOrMessage = 0, messageOrSizeBytes = "", customLatencyMs) {
         return LoadStrikeResponse.okWithPayload(payload, statusCode, sizeBytesOrMessage, messageOrSizeBytes, customLatencyMs);
     }
+    /**
+     * Creates a failed reply.
+     * Use this when a step or scenario should record an explicit failure response.
+     */
     static fail(...args) {
         const normalized = normalizeFailureResponseCall(args);
         const reply = {
@@ -326,6 +402,10 @@ export class LoadStrikeResponse {
         };
         return attachReplyProjection(reply);
     }
+    /**
+     * Creates a failed reply.
+     * Use this when a step or scenario should record an explicit failure response.
+     */
     static Fail(...args) {
         return LoadStrikeResponse.fail(...args);
     }
@@ -374,6 +454,10 @@ export class LoadStrikeStep {
     }
 }
 export class LoadStrikeSimulation {
+    /**
+     * Builds a constant injection load shape.
+     * Use this when requests should be injected at a fixed rate over a duration.
+     */
     static inject(rate, intervalSeconds, duringSeconds) {
         return attachLoadSimulationProjection({
             Kind: "Inject",
@@ -382,9 +466,17 @@ export class LoadStrikeSimulation {
             DuringSeconds: duringSeconds
         });
     }
+    /**
+     * Builds a constant injection load shape.
+     * Use this when requests should be injected at a fixed rate over a duration.
+     */
     static Inject(rate, intervalSeconds, duringSeconds) {
         return LoadStrikeSimulation.inject(rate, intervalSeconds, duringSeconds);
     }
+    /**
+     * Builds an iteration-limited constant-concurrency load shape.
+     * Use this when a fixed number of iterations should be shared across constant workers.
+     */
     static iterationsForConstant(copies, iterations) {
         return attachLoadSimulationProjection({
             Kind: "IterationsForConstant",
@@ -392,9 +484,17 @@ export class LoadStrikeSimulation {
             Iterations: iterations
         });
     }
+    /**
+     * Builds an iteration-limited constant-concurrency load shape.
+     * Use this when a fixed number of iterations should be shared across constant workers.
+     */
     static IterationsForConstant(copies, iterations) {
         return LoadStrikeSimulation.iterationsForConstant(copies, iterations);
     }
+    /**
+     * Builds an iteration-limited injection load shape.
+     * Use this when a fixed number of injected iterations should be executed.
+     */
     static iterationsForInject(rate, intervalSeconds, iterations) {
         return attachLoadSimulationProjection({
             Kind: "IterationsForInject",
@@ -403,9 +503,17 @@ export class LoadStrikeSimulation {
             Iterations: iterations
         });
     }
+    /**
+     * Builds an iteration-limited injection load shape.
+     * Use this when a fixed number of injected iterations should be executed.
+     */
     static IterationsForInject(rate, intervalSeconds, iterations) {
         return LoadStrikeSimulation.iterationsForInject(rate, intervalSeconds, iterations);
     }
+    /**
+     * Builds a constant-concurrency load shape.
+     * Use this when a fixed number of virtual users should stay active.
+     */
     static keepConstant(copies, duringSeconds) {
         return attachLoadSimulationProjection({
             Kind: "KeepConstant",
@@ -413,9 +521,17 @@ export class LoadStrikeSimulation {
             DuringSeconds: duringSeconds
         });
     }
+    /**
+     * Builds a constant-concurrency load shape.
+     * Use this when a fixed number of virtual users should stay active.
+     */
     static KeepConstant(copies, duringSeconds) {
         return LoadStrikeSimulation.keepConstant(copies, duringSeconds);
     }
+    /**
+     * Builds a randomized injection load shape.
+     * Use this when traffic should fluctuate between a minimum and maximum rate.
+     */
     static injectRandom(minRate, maxRate, intervalSeconds, duringSeconds) {
         return attachLoadSimulationProjection({
             Kind: "InjectRandom",
@@ -425,9 +541,17 @@ export class LoadStrikeSimulation {
             DuringSeconds: duringSeconds
         });
     }
+    /**
+     * Builds a randomized injection load shape.
+     * Use this when traffic should fluctuate between a minimum and maximum rate.
+     */
     static InjectRandom(minRate, maxRate, intervalSeconds, duringSeconds) {
         return LoadStrikeSimulation.injectRandom(minRate, maxRate, intervalSeconds, duringSeconds);
     }
+    /**
+     * Builds a ramping injection load shape.
+     * Use this when request rate should increase over time.
+     */
     static rampingInject(rate, intervalSeconds, duringSeconds) {
         return attachLoadSimulationProjection({
             Kind: "RampingInject",
@@ -436,9 +560,17 @@ export class LoadStrikeSimulation {
             DuringSeconds: duringSeconds
         });
     }
+    /**
+     * Builds a ramping injection load shape.
+     * Use this when request rate should increase over time.
+     */
     static RampingInject(rate, intervalSeconds, duringSeconds) {
         return LoadStrikeSimulation.rampingInject(rate, intervalSeconds, duringSeconds);
     }
+    /**
+     * Builds a ramping-concurrency load shape.
+     * Use this when the number of active virtual users should climb over time.
+     */
     static rampingConstant(copies, duringSeconds) {
         return attachLoadSimulationProjection({
             Kind: "RampingConstant",
@@ -446,20 +578,36 @@ export class LoadStrikeSimulation {
             DuringSeconds: duringSeconds
         });
     }
+    /**
+     * Builds a ramping-concurrency load shape.
+     * Use this when the number of active virtual users should climb over time.
+     */
     static RampingConstant(copies, duringSeconds) {
         return LoadStrikeSimulation.rampingConstant(copies, duringSeconds);
     }
+    /**
+     * Builds a pause segment in a load profile.
+     * Use this when a simulation should intentionally idle for a period.
+     */
     static pause(duringSeconds) {
         return attachLoadSimulationProjection({
             Kind: "Pause",
             DuringSeconds: duringSeconds
         });
     }
+    /**
+     * Builds a pause segment in a load profile.
+     * Use this when a simulation should intentionally idle for a period.
+     */
     static Pause(duringSeconds) {
         return LoadStrikeSimulation.pause(duringSeconds);
     }
 }
 export class LoadStrikeCounter {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(name, initialValueOrUnit = 0, unitOfMeasure = "") {
         this.type = "counter";
         this.name = requireNonEmpty(name, "Metric name is required.");
@@ -470,20 +618,40 @@ export class LoadStrikeCounter {
             ? 0
             : (Number.isFinite(initialValueOrUnit) ? Number(initialValueOrUnit) : 0);
     }
+    /**
+     * Adds a value to the current metric.
+     * Use this when a counter or gauge should be incremented by an explicit delta.
+     */
     add(value) {
         const next = Number.isFinite(value) ? Number(value) : 0;
         this.current += next;
         return this.current;
     }
+    /**
+     * Increments the current metric by one.
+     * Use this when events should simply be counted.
+     */
     increment(by = 1) {
         return this.add(by);
     }
+    /**
+     * Returns the current metric value.
+     * Use this when custom metric state needs to be inspected inside user code.
+     */
     value() {
         return this.current;
     }
+    /**
+     * Adds a value to the current metric.
+     * Use this when a counter or gauge should be incremented by an explicit delta.
+     */
     Add(value) {
         return this.add(value);
     }
+    /**
+     * Increments the current metric by one.
+     * Use this when events should simply be counted.
+     */
     Increment(by = 1) {
         return this.increment(by);
     }
@@ -498,6 +666,10 @@ export class LoadStrikeCounter {
     }
 }
 export class LoadStrikeGauge {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(name, initialValueOrUnit = 0, unitOfMeasure = "") {
         this.type = "gauge";
         this.name = requireNonEmpty(name, "Metric name is required.");
@@ -508,33 +680,69 @@ export class LoadStrikeGauge {
             ? 0
             : (Number.isFinite(initialValueOrUnit) ? Number(initialValueOrUnit) : 0);
     }
+    /**
+     * Sets the current gauge value.
+     * Use this when the latest observed value should replace the previous one.
+     */
     set(value) {
         this.current = Number.isFinite(value) ? Number(value) : 0;
         return this.current;
     }
+    /**
+     * Adds a value to the current metric.
+     * Use this when a counter or gauge should be incremented by an explicit delta.
+     */
     add(value) {
         const next = Number.isFinite(value) ? Number(value) : 0;
         this.current += next;
         return this.current;
     }
+    /**
+     * Increments the current metric by one.
+     * Use this when events should simply be counted.
+     */
     increment(by = 1) {
         return this.add(by);
     }
+    /**
+     * Decrements the current metric by one.
+     * Use this when a gauge should move down by a single unit.
+     */
     decrement(by = 1) {
         return this.add(-by);
     }
+    /**
+     * Returns the current metric value.
+     * Use this when custom metric state needs to be inspected inside user code.
+     */
     value() {
         return this.current;
     }
+    /**
+     * Sets the current gauge value.
+     * Use this when the latest observed value should replace the previous one.
+     */
     Set(value) {
         return this.set(value);
     }
+    /**
+     * Adds a value to the current metric.
+     * Use this when a counter or gauge should be incremented by an explicit delta.
+     */
     Add(value) {
         return this.add(value);
     }
+    /**
+     * Increments the current metric by one.
+     * Use this when events should simply be counted.
+     */
     Increment(by = 1) {
         return this.increment(by);
     }
+    /**
+     * Decrements the current metric by one.
+     * Use this when a gauge should move down by a single unit.
+     */
     Decrement(by = 1) {
         return this.decrement(by);
     }
@@ -549,21 +757,45 @@ export class LoadStrikeGauge {
     }
 }
 export class LoadStrikeMetric {
+    /**
+     * Creates a counter metric.
+     * Use this when a scenario should accumulate a monotonically increasing custom metric.
+     */
     static counter(name, initialValueOrUnit = 0, unitOfMeasure = "") {
         return new LoadStrikeCounter(name, initialValueOrUnit, unitOfMeasure);
     }
+    /**
+     * Creates a gauge metric.
+     * Use this when a scenario should track the latest value of a custom metric.
+     */
     static gauge(name, initialValueOrUnit = 0, unitOfMeasure = "") {
         return new LoadStrikeGauge(name, initialValueOrUnit, unitOfMeasure);
     }
+    /**
+     * Creates a counter metric.
+     * Use this when a scenario should accumulate a monotonically increasing custom metric.
+     */
     static Counter(name, initialValueOrUnit = 0, unitOfMeasure = "") {
         return LoadStrikeMetric.counter(name, initialValueOrUnit, unitOfMeasure);
     }
+    /**
+     * Creates a gauge metric.
+     * Use this when a scenario should track the latest value of a custom metric.
+     */
     static Gauge(name, initialValueOrUnit = 0, unitOfMeasure = "") {
         return LoadStrikeMetric.gauge(name, initialValueOrUnit, unitOfMeasure);
     }
+    /**
+     * Creates a counter metric.
+     * Use this when a scenario should accumulate a monotonically increasing custom metric.
+     */
     static CreateCounter(name, unitOfMeasure = "") {
         return new LoadStrikeCounter(name, 0, unitOfMeasure);
     }
+    /**
+     * Creates a gauge metric.
+     * Use this when a scenario should track the latest value of a custom metric.
+     */
     static CreateGauge(name, unitOfMeasure = "") {
         return new LoadStrikeGauge(name, 0, unitOfMeasure);
     }
@@ -684,15 +916,31 @@ export class LoadStrikeContext {
         this.registeredScenarios = [...registeredScenarios];
         this.runArgs = [...runArgs];
     }
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static create() {
         return new LoadStrikeContext();
     }
+    /**
+     * Exposes the public toObject operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     toObject() {
         return { ...this.values };
     }
+    /**
+     * Builds the current configuration into a runnable context.
+     * Use this when you want to inspect or reuse the final run settings before execution.
+     */
     buildContext() {
         return this;
     }
+    /**
+     * Builds the current configuration into a runnable context.
+     * Use this when you want to inspect or reuse the final run settings before execution.
+     */
     BuildContext() {
         return this.buildContext();
     }
@@ -714,6 +962,10 @@ export class LoadStrikeContext {
         const args = normalizeRunArgsInput(argsOrSingleArray);
         return this.run(args);
     }
+    /**
+     * Exposes the public toRunnerOptions operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     toRunnerOptions() {
         const normalizedValues = normalizeRunContextCollectionShapes(this.values);
         return {
@@ -786,27 +1038,59 @@ export class LoadStrikeContext {
     Configure(input) {
         return this.configure(input);
     }
+    /**
+     * Copies settings from an existing context snapshot.
+     * Use this when a runner should inherit configuration that was already assembled elsewhere.
+     */
     configureContext(context) {
         return this.configure(context);
     }
+    /**
+     * Copies settings from an existing context snapshot.
+     * Use this when a runner should inherit configuration that was already assembled elsewhere.
+     */
     ConfigureContext(context) {
         return this.configureContext(context);
     }
+    /**
+     * Toggles realtime console metric output.
+     * Use this when a local run or CI log should stream live throughput and latency updates.
+     */
     displayConsoleMetrics(enable) {
         return this.DisplayConsoleMetrics(enable);
     }
+    /**
+     * Toggles realtime console metric output.
+     * Use this when a local run or CI log should stream live throughput and latency updates.
+     */
     DisplayConsoleMetrics(enable) {
         return this.mergeValues({ ConsoleMetricsEnabled: Boolean(enable) });
     }
+    /**
+     * Toggles local development cluster mode.
+     * Use this when you want to simulate coordinator and agent behavior on a single machine.
+     */
     enableLocalDevCluster(enable) {
         return this.EnableLocalDevCluster(enable);
     }
+    /**
+     * Toggles local development cluster mode.
+     * Use this when you want to simulate coordinator and agent behavior on a single machine.
+     */
     EnableLocalDevCluster(enable) {
         return this.mergeValues({ LocalDevClusterEnabled: Boolean(enable) });
     }
+    /**
+     * Loads run settings from a JSON config file.
+     * Use this when configuration should come from a checked-in or generated config document.
+     */
     loadConfig(path) {
         return this.LoadConfig(path);
     }
+    /**
+     * Loads run settings from a JSON config file.
+     * Use this when configuration should come from a checked-in or generated config document.
+     */
     LoadConfig(path) {
         const configPath = requireNonEmpty(path, "Config path must be provided.");
         const loaded = loadJsonObject(configPath);
@@ -816,9 +1100,17 @@ export class LoadStrikeContext {
             ...extractContextOverridesFromConfig(loaded)
         });
     }
+    /**
+     * Loads infrastructure settings for sinks, plugins, or transport dependencies.
+     * Use this when runtime integrations depend on external connection details.
+     */
     loadInfraConfig(path) {
         return this.LoadInfraConfig(path);
     }
+    /**
+     * Loads infrastructure settings for sinks, plugins, or transport dependencies.
+     * Use this when runtime integrations depend on external connection details.
+     */
     LoadInfraConfig(path) {
         const infraConfigPath = requireNonEmpty(path, "Infra config path must be provided.");
         return this.mergeValues({
@@ -826,87 +1118,191 @@ export class LoadStrikeContext {
             InfraConfig: loadJsonObject(infraConfigPath)
         });
     }
+    /**
+     * Sets the agent group for this node or run.
+     * Use this when only a subset of agents should pick up a particular workload.
+     */
     withAgentGroup(agentGroup) {
         return this.WithAgentGroup(agentGroup);
     }
+    /**
+     * Sets the agent group for this node or run.
+     * Use this when only a subset of agents should pick up a particular workload.
+     */
     WithAgentGroup(agentGroup) {
         return this.mergeValues({ AgentGroup: requireNonEmpty(agentGroup, "Agent group must be provided.") });
     }
+    /**
+     * Sets the requested agent count.
+     * Use this when a coordinator should fan work out across a specific number of agents.
+     */
     withAgentsCount(agentsCount) {
         return this.WithAgentsCount(agentsCount);
     }
+    /**
+     * Sets the requested agent count.
+     * Use this when a coordinator should fan work out across a specific number of agents.
+     */
     WithAgentsCount(agentsCount) {
         if (!Number.isFinite(agentsCount) || agentsCount <= 0) {
             throw new RangeError("Agents count should be greater than zero.");
         }
         return this.mergeValues({ AgentsCount: Math.trunc(agentsCount) });
     }
+    /**
+     * Targets a shared set of scenarios.
+     * Use this when only selected scenarios should execute for the current node or run.
+     */
     withTargetScenarios(...scenarioNames) {
         return this.WithTargetScenarios(...scenarioNames);
     }
+    /**
+     * Targets a shared set of scenarios.
+     * Use this when only selected scenarios should execute for the current node or run.
+     */
     WithTargetScenarios(...scenarioNames) {
         return this.mergeValues({ TargetScenarios: validateScenarioNames(scenarioNames) });
     }
+    /**
+     * Targets scenarios for agent nodes only.
+     * Use this when agents should execute only a subset of the registered scenarios.
+     */
     withAgentTargetScenarios(...scenarioNames) {
         return this.WithAgentTargetScenarios(...scenarioNames);
     }
+    /**
+     * Targets scenarios for agent nodes only.
+     * Use this when agents should execute only a subset of the registered scenarios.
+     */
     WithAgentTargetScenarios(...scenarioNames) {
         return this.mergeValues({ AgentTargetScenarios: validateScenarioNames(scenarioNames) });
     }
+    /**
+     * Targets scenarios for the coordinator only.
+     * Use this when orchestration or control-node work should run on the coordinator itself.
+     */
     withCoordinatorTargetScenarios(...scenarioNames) {
         return this.WithCoordinatorTargetScenarios(...scenarioNames);
     }
+    /**
+     * Targets scenarios for the coordinator only.
+     * Use this when orchestration or control-node work should run on the coordinator itself.
+     */
     WithCoordinatorTargetScenarios(...scenarioNames) {
         return this.mergeValues({ CoordinatorTargetScenarios: validateScenarioNames(scenarioNames) });
     }
+    /**
+     * Sets the runner key used for licensing validation.
+     * Use this when the run must authenticate against the licensing API before it starts.
+     */
     withRunnerKey(runnerKey) {
         return this.WithRunnerKey(runnerKey);
     }
+    /**
+     * Sets the runner key used for licensing validation.
+     * Use this when the run must authenticate against the licensing API before it starts.
+     */
     WithRunnerKey(runnerKey) {
         return this.mergeValues({ RunnerKey: requireNonEmpty(runnerKey, "Runner key must be provided.") });
     }
+    /**
+     * Sets how long the SDK waits for licensing validation to complete.
+     * Use this when control-plane latency or private networking requires a longer validation window.
+     */
     withLicenseValidationTimeout(timeoutSeconds) {
         return this.WithLicenseValidationTimeout(timeoutSeconds);
     }
+    /**
+     * Sets how long the SDK waits for licensing validation to complete.
+     * Use this when control-plane latency or private networking requires a longer validation window.
+     */
     WithLicenseValidationTimeout(timeoutSeconds) {
         if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
             throw new RangeError("License validation timeout should be greater than zero.");
         }
         return this.mergeValues({ LicenseValidationTimeoutSeconds: timeoutSeconds });
     }
+    /**
+     * Sets the runtime node type.
+     * Use this when a process should behave as a single node, coordinator, or agent.
+     */
     withNodeType(nodeType) {
         return this.WithNodeType(nodeType);
     }
+    /**
+     * Sets the runtime node type.
+     * Use this when a process should behave as a single node, coordinator, or agent.
+     */
     WithNodeType(nodeType) {
         return this.mergeValues({ NodeType: parseNodeTypeToken(nodeType) });
     }
+    /**
+     * Sets the NATS server URL used for distributed cluster coordination.
+     * Use this when coordinator and agent nodes communicate over NATS.
+     */
     withNatsServerUrl(natsUrl) {
         return this.WithNatsServerUrl(natsUrl);
     }
+    /**
+     * Sets the NATS server URL used for distributed cluster coordination.
+     * Use this when coordinator and agent nodes communicate over NATS.
+     */
     WithNatsServerUrl(natsUrl) {
         return this.mergeValues({ NatsServerUrl: requireNonEmpty(natsUrl, "NATS server URL must be provided.") });
     }
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     withoutReports() {
         return this.WithoutReports();
     }
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     WithoutReports() {
         return this.mergeValues({ ReportsEnabled: false });
     }
+    /**
+     * Sets the base file name for generated reports.
+     * Use this when exported reports should use a predictable naming convention.
+     */
     withReportFileName(reportFileName) {
         return this.WithReportFileName(reportFileName);
     }
+    /**
+     * Sets the base file name for generated reports.
+     * Use this when exported reports should use a predictable naming convention.
+     */
     WithReportFileName(reportFileName) {
         return this.mergeValues({ ReportFileName: requireNonEmpty(reportFileName, "Report file name must be provided.") });
     }
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     withReportFolder(reportFolderPath) {
         return this.WithReportFolder(reportFolderPath);
     }
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     WithReportFolder(reportFolderPath) {
         return this.mergeValues({ ReportFolderPath: requireNonEmpty(reportFolderPath, "Report folder path must be provided.") });
     }
+    /**
+     * Restricts generated reports to specific formats.
+     * Use this when you want only selected report artifacts such as HTML, CSV, or Markdown.
+     */
     withReportFormats(...reportFormats) {
         return this.WithReportFormats(...reportFormats);
     }
+    /**
+     * Restricts generated reports to specific formats.
+     * Use this when you want only selected report artifacts such as HTML, CSV, or Markdown.
+     */
     WithReportFormats(...reportFormats) {
         if (!reportFormats.length) {
             throw new Error("At least one report format should be provided.");
@@ -917,18 +1313,34 @@ export class LoadStrikeContext {
         }
         return this.mergeValues({ ReportFormats: normalized });
     }
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     withReportingInterval(intervalSeconds) {
         return this.WithReportingInterval(intervalSeconds);
     }
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     WithReportingInterval(intervalSeconds) {
         if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) {
             throw new RangeError("Reporting interval should be greater than zero.");
         }
         return this.mergeValues({ ReportingIntervalSeconds: intervalSeconds });
     }
+    /**
+     * Registers one or more reporting sinks.
+     * Use this when run results must be pushed to external observability or storage systems.
+     */
     withReportingSinks(...sinks) {
         return this.WithReportingSinks(...sinks);
     }
+    /**
+     * Registers one or more reporting sinks.
+     * Use this when run results must be pushed to external observability or storage systems.
+     */
     WithReportingSinks(...sinks) {
         if (!sinks.length) {
             throw new Error("At least one reporting sink should be provided.");
@@ -939,9 +1351,17 @@ export class LoadStrikeContext {
         validateNamedReportingSinks(sinks);
         return this.mergeValues({ ReportingSinks: sinks });
     }
+    /**
+     * Registers runtime policies for the run.
+     * Use this when scenario selection or step execution should obey policy callbacks.
+     */
     withRuntimePolicies(...policies) {
         return this.WithRuntimePolicies(...policies);
     }
+    /**
+     * Registers runtime policies for the run.
+     * Use this when scenario selection or step execution should obey policy callbacks.
+     */
     WithRuntimePolicies(...policies) {
         if (!policies.length) {
             throw new Error("At least one runtime policy should be provided.");
@@ -951,17 +1371,33 @@ export class LoadStrikeContext {
         }
         return this.mergeValues({ RuntimePolicies: policies });
     }
+    /**
+     * Sets how runtime policy failures are handled.
+     * Use this when policy errors should either fail fast or be tolerated.
+     */
     withRuntimePolicyErrorMode(mode) {
         return this.WithRuntimePolicyErrorMode(mode);
     }
+    /**
+     * Sets how runtime policy failures are handled.
+     * Use this when policy errors should either fail fast or be tolerated.
+     */
     WithRuntimePolicyErrorMode(mode) {
         return this.mergeValues({
             RuntimePolicyErrorMode: normalizedRuntimePolicyErrorMode(mode)
         });
     }
+    /**
+     * Registers worker plugins for the run.
+     * Use this when custom plugin data should be collected alongside run results.
+     */
     withWorkerPlugins(...plugins) {
         return this.WithWorkerPlugins(...plugins);
     }
+    /**
+     * Registers worker plugins for the run.
+     * Use this when custom plugin data should be collected alongside run results.
+     */
     WithWorkerPlugins(...plugins) {
         if (!plugins.length) {
             throw new Error("At least one worker plugin should be provided.");
@@ -972,71 +1408,143 @@ export class LoadStrikeContext {
         validateNamedWorkerPlugins(plugins);
         return this.mergeValues({ WorkerPlugins: plugins });
     }
+    /**
+     * Sets the minimum runtime log level.
+     * Use this when the run should emit less or more operational detail.
+     */
     withMinimumLogLevel(minimumLogLevel) {
         return this.WithMinimumLogLevel(minimumLogLevel);
     }
+    /**
+     * Sets the minimum runtime log level.
+     * Use this when the run should emit less or more operational detail.
+     */
     WithMinimumLogLevel(minimumLogLevel) {
         return this.mergeValues({
             MinimumLogLevel: parseMinimumLogLevelToken(requireNonEmpty(minimumLogLevel, "Minimum log level must be provided."))
         });
     }
+    /**
+     * Supplies a custom logger configuration factory.
+     * Use this when the default runtime logging output is not enough for your environment.
+     */
     withLoggerConfig(loggerConfig) {
         return this.WithLoggerConfig(loggerConfig);
     }
+    /**
+     * Supplies a custom logger configuration factory.
+     * Use this when the default runtime logging output is not enough for your environment.
+     */
     WithLoggerConfig(loggerConfig) {
         if (typeof loggerConfig !== "function") {
             throw new TypeError("Logger config must be provided.");
         }
         return this.mergeValues({ LoggerConfig: loggerConfig });
     }
+    /**
+     * Sets the timeout for scenario completion.
+     * Use this when long-running scenarios need an explicit completion window.
+     */
     withScenarioCompletionTimeout(timeoutSeconds) {
         return this.WithScenarioCompletionTimeout(timeoutSeconds);
     }
+    /**
+     * Sets the timeout for scenario completion.
+     * Use this when long-running scenarios need an explicit completion window.
+     */
     WithScenarioCompletionTimeout(timeoutSeconds) {
         if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
             throw new RangeError("Scenario completion timeout should be greater than zero.");
         }
         return this.mergeValues({ ScenarioCompletionTimeoutSeconds: timeoutSeconds });
     }
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     withClusterCommandTimeout(timeoutSeconds) {
         return this.WithClusterCommandTimeout(timeoutSeconds);
     }
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     WithClusterCommandTimeout(timeoutSeconds) {
         if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
             throw new RangeError("Cluster command timeout should be greater than zero.");
         }
         return this.mergeValues({ ClusterCommandTimeoutSeconds: timeoutSeconds });
     }
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     withRestartIterationMaxAttempts(attempts) {
         return this.WithRestartIterationMaxAttempts(attempts);
     }
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     WithRestartIterationMaxAttempts(attempts) {
         if (!Number.isFinite(attempts) || attempts < 0) {
             throw new RangeError("Restart iteration max attempts should be zero or greater.");
         }
         return this.mergeValues({ RestartIterationMaxAttempts: Math.trunc(attempts) });
     }
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     withSessionId(sessionId) {
         return this.WithSessionId(sessionId);
     }
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     WithSessionId(sessionId) {
         return this.mergeValues({ SessionId: requireNonEmpty(sessionId, "Session id must be provided.") });
     }
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     withTestSuite(testSuite) {
         return this.WithTestSuite(testSuite);
     }
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     WithTestSuite(testSuite) {
         return this.mergeValues({ TestSuite: requireNonEmpty(testSuite, "Test suite must be provided.") });
     }
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     withTestName(testName) {
         return this.WithTestName(testName);
     }
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     WithTestName(testName) {
         return this.mergeValues({ TestName: requireNonEmpty(testName, "Test name must be provided.") });
     }
+    /**
+     * Sets the cluster identifier for this run.
+     * Use this when multiple cluster nodes must join the same distributed execution.
+     */
     withClusterId(clusterId) {
         return this.WithClusterId(clusterId);
     }
+    /**
+     * Sets the cluster identifier for this run.
+     * Use this when multiple cluster nodes must join the same distributed execution.
+     */
     WithClusterId(clusterId) {
         return this.mergeValues({ ClusterId: requireNonEmpty(clusterId, "Cluster id must be provided.") });
     }
@@ -1049,6 +1557,10 @@ export class LoadStrikeContext {
         this.runArgs = [...runArgs];
         return this;
     }
+    /**
+     * Configures registered scenarios for this SDK object.
+     * Use this when registered scenarios should be set explicitly before the run starts.
+     */
     withRegisteredScenarios(...scenarios) {
         return this.assignState(this.values, scenarios, this.runArgs);
     }
@@ -1084,57 +1596,105 @@ export class LoadStrikeScenario {
     static CreateAsync(name, runHandler) {
         return LoadStrikeScenario.createAsync(name, runHandler);
     }
+    /**
+     * Creates a placeholder scenario that returns the default success reply.
+     * Use this when you want a scenario shell before adding setup, cleanup, or more detailed behavior.
+     */
     static empty(name) {
         return LoadStrikeScenario.create(name, () => LoadStrikeResponse.ok());
     }
+    /**
+     * Creates a placeholder scenario that returns the default success reply.
+     * Use this when you want a scenario shell before adding setup, cleanup, or more detailed behavior.
+     */
     static Empty(name) {
         return LoadStrikeScenario.empty(name);
     }
     get Name() {
         return this.name;
     }
+    /**
+     * Configures init for this SDK object.
+     * Use this when init should be set explicitly before the run starts.
+     */
     withInit(handler) {
         if (typeof handler !== "function") {
             throw new TypeError("Init handler must be provided.");
         }
         return new LoadStrikeScenario(this.name, this.runHandler, handler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
+    /**
+     * Configures init async for this SDK object.
+     * Use this when init async should be set explicitly before the run starts.
+     */
     withInitAsync(handler) {
         return this.withInit(handler);
     }
+    /**
+     * Configures clean for this SDK object.
+     * Use this when clean should be set explicitly before the run starts.
+     */
     withClean(handler) {
         if (typeof handler !== "function") {
             throw new TypeError("Clean handler must be provided.");
         }
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, handler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
+    /**
+     * Configures clean async for this SDK object.
+     * Use this when clean async should be set explicitly before the run starts.
+     */
     withCleanAsync(handler) {
         return this.withClean(handler);
     }
+    /**
+     * Configures max fail count for this SDK object.
+     * Use this when max fail count should be set explicitly before the run starts.
+     */
     withMaxFailCount(maxFailCount) {
         if (!Number.isFinite(maxFailCount)) {
             throw new RangeError("maxFailCount should be a finite number.");
         }
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, Math.trunc(maxFailCount), this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
+    /**
+     * Configures out warm up for this SDK object.
+     * Use this when out warm up should be set explicitly before the run starts.
+     */
     withoutWarmUp() {
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, true, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
+    /**
+     * Configures warm up duration for this SDK object.
+     * Use this when warm up duration should be set explicitly before the run starts.
+     */
     withWarmUpDuration(durationSeconds) {
         if (!Number.isFinite(durationSeconds)) {
             throw new RangeError("Warmup duration should be a finite number.");
         }
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, durationSeconds, this.weight, this.restartIterationOnFail);
     }
+    /**
+     * Configures weight for this SDK object.
+     * Use this when weight should be set explicitly before the run starts.
+     */
     withWeight(weight) {
         if (!Number.isFinite(weight)) {
             throw new RangeError("Weight should be a finite number.");
         }
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, Math.trunc(weight), this.restartIterationOnFail);
     }
+    /**
+     * Configures restart iteration on fail for this SDK object.
+     * Use this when restart iteration on fail should be set explicitly before the run starts.
+     */
     withRestartIterationOnFail(shouldRestart) {
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, Boolean(shouldRestart));
     }
+    /**
+     * Configures cross platform tracking for this SDK object.
+     * Use this when cross platform tracking should be set explicitly before the run starts.
+     */
     withCrossPlatformTracking(configuration) {
         if (!configuration || typeof configuration !== "object" || Array.isArray(configuration)) {
             throw new TypeError("Tracking configuration must be provided.");
@@ -1152,39 +1712,79 @@ export class LoadStrikeScenario {
         validateRuntimeTrackingConfiguration(copied, sourceEndpoint, destinationEndpoint);
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, copied, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
+    /**
+     * Configures load simulations for this SDK object.
+     * Use this when load simulations should be set explicitly before the run starts.
+     */
     withLoadSimulations(...simulations) {
         if (!simulations.length) {
             throw new Error("At least one load simulation should be provided.");
         }
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, simulations.map((simulation) => attachLoadSimulationProjection({ ...simulation })), this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
+    /**
+     * Configures thresholds for this SDK object.
+     * Use this when thresholds should be set explicitly before the run starts.
+     */
     withThresholds(...thresholds) {
         if (!thresholds.length) {
             throw new Error("At least one threshold should be provided.");
         }
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, thresholds.map((threshold) => ({ ...threshold })), this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail);
     }
+    /**
+     * Returns simulations.
+     * Use this when simulations is required for branching, logging, or assertions.
+     */
     getSimulations() {
         return this.loadSimulations.map((simulation) => attachLoadSimulationProjection({ ...simulation }));
     }
+    /**
+     * Returns thresholds.
+     * Use this when thresholds is required for branching, logging, or assertions.
+     */
     getThresholds() {
         return this.thresholds;
     }
+    /**
+     * Returns tracking configuration.
+     * Use this when tracking configuration is required for branching, logging, or assertions.
+     */
     getTrackingConfiguration() {
         return this.trackingConfiguration ? { ...this.trackingConfiguration } : undefined;
     }
+    /**
+     * Returns max fail count.
+     * Use this when max fail count is required for branching, logging, or assertions.
+     */
     getMaxFailCount() {
         return this.maxFailCount;
     }
+    /**
+     * Exposes the public isWithoutWarmUp operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     isWithoutWarmUp() {
         return this.withoutWarmUpValue;
     }
+    /**
+     * Returns warm up duration seconds.
+     * Use this when warm up duration seconds is required for branching, logging, or assertions.
+     */
     getWarmUpDurationSeconds() {
         return this.warmUpDurationSeconds;
     }
+    /**
+     * Returns weight.
+     * Use this when weight is required for branching, logging, or assertions.
+     */
     getWeight() {
         return this.weight;
     }
+    /**
+     * Exposes the public shouldRestartIterationOnFail operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     shouldRestartIterationOnFail() {
         return this.restartIterationOnFail;
     }
@@ -1210,39 +1810,87 @@ export class LoadStrikeScenario {
             return LoadStrikeResponse.fail("exception", resolveRuntimeErrorMessage(error, "scenario failed"), 0);
         }
     }
+    /**
+     * Configures cross platform tracking for this SDK object.
+     * Use this when cross platform tracking should be set explicitly before the run starts.
+     */
     WithCrossPlatformTracking(configuration) {
         return this.withCrossPlatformTracking(configuration);
     }
+    /**
+     * Configures init for this SDK object.
+     * Use this when init should be set explicitly before the run starts.
+     */
     WithInit(handler) {
         return this.withInit(handler);
     }
+    /**
+     * Configures init async for this SDK object.
+     * Use this when init async should be set explicitly before the run starts.
+     */
     WithInitAsync(handler) {
         return this.withInitAsync(handler);
     }
+    /**
+     * Configures clean for this SDK object.
+     * Use this when clean should be set explicitly before the run starts.
+     */
     WithClean(handler) {
         return this.withClean(handler);
     }
+    /**
+     * Configures clean async for this SDK object.
+     * Use this when clean async should be set explicitly before the run starts.
+     */
     WithCleanAsync(handler) {
         return this.withCleanAsync(handler);
     }
+    /**
+     * Configures load simulations for this SDK object.
+     * Use this when load simulations should be set explicitly before the run starts.
+     */
     WithLoadSimulations(...simulations) {
         return this.withLoadSimulations(...simulations);
     }
+    /**
+     * Configures max fail count for this SDK object.
+     * Use this when max fail count should be set explicitly before the run starts.
+     */
     WithMaxFailCount(maxFailCount) {
         return this.withMaxFailCount(maxFailCount);
     }
+    /**
+     * Configures out warm up for this SDK object.
+     * Use this when out warm up should be set explicitly before the run starts.
+     */
     WithoutWarmUp() {
         return this.withoutWarmUp();
     }
+    /**
+     * Configures restart iteration on fail for this SDK object.
+     * Use this when restart iteration on fail should be set explicitly before the run starts.
+     */
     WithRestartIterationOnFail(shouldRestart) {
         return this.withRestartIterationOnFail(shouldRestart);
     }
+    /**
+     * Configures thresholds for this SDK object.
+     * Use this when thresholds should be set explicitly before the run starts.
+     */
     WithThresholds(...thresholds) {
         return this.withThresholds(...thresholds);
     }
+    /**
+     * Configures warm up duration for this SDK object.
+     * Use this when warm up duration should be set explicitly before the run starts.
+     */
     WithWarmUpDuration(durationSeconds) {
         return this.withWarmUpDuration(durationSeconds);
     }
+    /**
+     * Configures weight for this SDK object.
+     * Use this when weight should be set explicitly before the run starts.
+     */
     WithWeight(weight) {
         return this.withWeight(weight);
     }
@@ -1253,115 +1901,251 @@ export class LoadStrikeRunner {
         this.options = normalizeRunnerOptionCollectionShapes(options);
         this.contextConfigurators = [...contextConfigurators];
     }
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static create() {
         return new LoadStrikeRunner([], {});
     }
+    /**
+     * Creates a new instance of this public SDK type.
+     * Use this when you are starting a run definition from scratch.
+     */
     static Create() {
         return LoadStrikeRunner.create();
     }
+    /**
+     * Registers one or more scenarios on a fresh runnable context.
+     * Use this when you want a context immediately without composing a runner first.
+     */
     static registerScenarios(...scenarios) {
         validateRegisteredScenarios(scenarios);
         return new LoadStrikeContext({}, scenarios);
     }
+    /**
+     * Registers one or more scenarios on a fresh runnable context.
+     * Use this when you want a context immediately without composing a runner first.
+     */
     static RegisterScenarios(...scenarios) {
         return LoadStrikeRunner.registerScenarios(...scenarios);
     }
+    /**
+     * Toggles realtime console metric output.
+     * Use this when a local run or CI log should stream live throughput and latency updates.
+     */
     static DisplayConsoleMetrics(context, enable) {
         return context.DisplayConsoleMetrics(enable);
     }
+    /**
+     * Toggles local development cluster mode.
+     * Use this when you want to simulate coordinator and agent behavior on a single machine.
+     */
     static EnableLocalDevCluster(context, enable) {
         return context.EnableLocalDevCluster(enable);
     }
+    /**
+     * Loads run settings from a JSON config file.
+     * Use this when configuration should come from a checked-in or generated config document.
+     */
     static LoadConfig(context, path) {
         return context.LoadConfig(path);
     }
+    /**
+     * Loads infrastructure settings for sinks, plugins, or transport dependencies.
+     * Use this when runtime integrations depend on external connection details.
+     */
     static LoadInfraConfig(context, path) {
         return context.LoadInfraConfig(path);
     }
+    /**
+     * Executes the configured workload through the SDK runtime.
+     * Use this when configuration is complete and you are ready to start the run.
+     */
     static Run(context, ...args) {
         return context.Run(args);
     }
+    /**
+     * Sets the agent group for this node or run.
+     * Use this when only a subset of agents should pick up a particular workload.
+     */
     static WithAgentGroup(context, agentGroup) {
         return context.WithAgentGroup(agentGroup);
     }
+    /**
+     * Sets the requested agent count.
+     * Use this when a coordinator should fan work out across a specific number of agents.
+     */
     static WithAgentsCount(context, agentsCount) {
         return context.WithAgentsCount(agentsCount);
     }
+    /**
+     * Targets scenarios for agent nodes only.
+     * Use this when agents should execute only a subset of the registered scenarios.
+     */
     static WithAgentTargetScenarios(context, ...scenarioNames) {
         return context.WithAgentTargetScenarios(...scenarioNames);
     }
+    /**
+     * Sets the cluster identifier for this run.
+     * Use this when multiple cluster nodes must join the same distributed execution.
+     */
     static WithClusterId(context, clusterId) {
         return context.WithClusterId(clusterId);
     }
+    /**
+     * Targets scenarios for the coordinator only.
+     * Use this when orchestration or control-node work should run on the coordinator itself.
+     */
     static WithCoordinatorTargetScenarios(context, ...scenarioNames) {
         return context.WithCoordinatorTargetScenarios(...scenarioNames);
     }
+    /**
+     * Sets the runner key used for licensing validation.
+     * Use this when the run must authenticate against the licensing API before it starts.
+     */
     static WithRunnerKey(context, runnerKey) {
         return context.WithRunnerKey(runnerKey);
     }
+    /**
+     * Sets how long the SDK waits for licensing validation to complete.
+     * Use this when control-plane latency or private networking requires a longer validation window.
+     */
     static WithLicenseValidationTimeout(context, timeoutSeconds) {
         return context.WithLicenseValidationTimeout(timeoutSeconds);
     }
+    /**
+     * Supplies a custom logger configuration factory.
+     * Use this when the default runtime logging output is not enough for your environment.
+     */
     static WithLoggerConfig(context, loggerConfig) {
         return context.WithLoggerConfig(loggerConfig);
     }
+    /**
+     * Sets the minimum runtime log level.
+     * Use this when the run should emit less or more operational detail.
+     */
     static WithMinimumLogLevel(context, minimumLogLevel) {
         return context.WithMinimumLogLevel(minimumLogLevel);
     }
+    /**
+     * Sets the NATS server URL used for distributed cluster coordination.
+     * Use this when coordinator and agent nodes communicate over NATS.
+     */
     static WithNatsServerUrl(context, natsUrl) {
         return context.WithNatsServerUrl(natsUrl);
     }
     static WithNodeType(context, nodeType) {
         return context.WithNodeType(nodeType);
     }
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     static WithoutReports(context) {
         return context.WithoutReports();
     }
+    /**
+     * Sets the base file name for generated reports.
+     * Use this when exported reports should use a predictable naming convention.
+     */
     static WithReportFileName(context, reportFileName) {
         return context.WithReportFileName(reportFileName);
     }
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     static WithReportFolder(context, reportFolderPath) {
         return context.WithReportFolder(reportFolderPath);
     }
     static WithReportFormats(context, ...reportFormats) {
         return context.WithReportFormats(...reportFormats);
     }
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     static WithReportingInterval(context, intervalSeconds) {
         return context.WithReportingInterval(intervalSeconds);
     }
+    /**
+     * Registers one or more reporting sinks.
+     * Use this when run results must be pushed to external observability or storage systems.
+     */
     static WithReportingSinks(context, ...sinks) {
         return context.WithReportingSinks(...sinks);
     }
+    /**
+     * Registers runtime policies for the run.
+     * Use this when scenario selection or step execution should obey policy callbacks.
+     */
     static WithRuntimePolicies(context, ...policies) {
         return context.WithRuntimePolicies(...policies);
     }
     static WithRuntimePolicyErrorMode(context, mode) {
         return context.WithRuntimePolicyErrorMode(mode);
     }
+    /**
+     * Sets the timeout for scenario completion.
+     * Use this when long-running scenarios need an explicit completion window.
+     */
     static WithScenarioCompletionTimeout(context, timeoutSeconds) {
         return context.WithScenarioCompletionTimeout(timeoutSeconds);
     }
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     static WithClusterCommandTimeout(context, timeoutSeconds) {
         return context.WithClusterCommandTimeout(timeoutSeconds);
     }
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     static WithRestartIterationMaxAttempts(context, attempts) {
         return context.WithRestartIterationMaxAttempts(attempts);
     }
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     static WithSessionId(context, sessionId) {
         return context.WithSessionId(sessionId);
     }
+    /**
+     * Targets a shared set of scenarios.
+     * Use this when only selected scenarios should execute for the current node or run.
+     */
     static WithTargetScenarios(context, ...scenarioNames) {
         return context.WithTargetScenarios(...scenarioNames);
     }
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     static WithTestName(context, testName) {
         return context.WithTestName(testName);
     }
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     static WithTestSuite(context, testSuite) {
         return context.WithTestSuite(testSuite);
     }
+    /**
+     * Registers worker plugins for the run.
+     * Use this when custom plugin data should be collected alongside run results.
+     */
     static WithWorkerPlugins(context, ...plugins) {
         return context.WithWorkerPlugins(...plugins);
     }
+    /**
+     * Adds a scenario to the current runner.
+     * Use this when the run should include one more scenario definition.
+     */
     addScenario(scenario) {
         if (!(scenario instanceof LoadStrikeScenario)) {
             throw new TypeError("Scenario must be provided.");
@@ -1369,9 +2153,17 @@ export class LoadStrikeRunner {
         this.scenarios = [...this.scenarios, scenario];
         return this;
     }
+    /**
+     * Adds a scenario to the current runner.
+     * Use this when the run should include one more scenario definition.
+     */
     AddScenario(scenario) {
         return this.addScenario(scenario);
     }
+    /**
+     * Adds multiple scenarios to the current runner.
+     * Use this when the run should execute a batch of scenario definitions together.
+     */
     addScenarios(...scenarios) {
         if (!scenarios.length) {
             throw new Error("At least one scenario must be provided.");
@@ -1382,9 +2174,17 @@ export class LoadStrikeRunner {
         this.scenarios = [...this.scenarios, ...scenarios];
         return this;
     }
+    /**
+     * Adds multiple scenarios to the current runner.
+     * Use this when the run should execute a batch of scenario definitions together.
+     */
     AddScenarios(...scenarios) {
         return this.addScenarios(...scenarios);
     }
+    /**
+     * Applies a grouped configuration change to the current builder or context.
+     * Use this when several related settings should be supplied in one step.
+     */
     configure(options) {
         if (!options || typeof options !== "object" || Array.isArray(options)) {
             throw new TypeError("Configure options must be a non-null object.");
@@ -1411,6 +2211,10 @@ export class LoadStrikeRunner {
         }
         return this.configure(input);
     }
+    /**
+     * Copies settings from an existing context snapshot.
+     * Use this when a runner should inherit configuration that was already assembled elsewhere.
+     */
     configureContext(context) {
         if (!context || typeof context !== "object" || Array.isArray(context)) {
             throw new TypeError("Configure context must be a LoadStrikeContext or run context object.");
@@ -1420,66 +2224,138 @@ export class LoadStrikeRunner {
             : new LoadStrikeContext(context);
         return this.configure(runtimeContext.toRunnerOptions());
     }
+    /**
+     * Copies settings from an existing context snapshot.
+     * Use this when a runner should inherit configuration that was already assembled elsewhere.
+     */
     ConfigureContext(context) {
         return this.configureContext(context);
     }
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     withTestSuite(testSuite) {
         return this.configure({ testSuite: requireNonEmpty(testSuite, "Test suite must be provided.") });
     }
+    /**
+     * Sets the test suite label for the run.
+     * Use this when related tests should be grouped under a suite name.
+     */
     WithTestSuite(testSuite) {
         return this.withTestSuite(testSuite);
     }
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     withTestName(testName) {
         return this.configure({ testName: requireNonEmpty(testName, "Test name must be provided.") });
     }
+    /**
+     * Sets the test name label for the run.
+     * Use this when reports and logs should expose a human-readable test identifier.
+     */
     WithTestName(testName) {
         return this.withTestName(testName);
     }
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     withSessionId(sessionId) {
         return this.configure({ sessionId: requireNonEmpty(sessionId, "Session id must be provided.") });
     }
+    /**
+     * Sets the session identifier for this run.
+     * Use this when downstream logs, reports, or external systems need a stable session id.
+     */
     WithSessionId(sessionId) {
         return this.withSessionId(sessionId);
     }
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     withReportFolder(reportFolderPath) {
         return this.configure({ reportFolderPath: requireNonEmpty(reportFolderPath, "Report folder path must be provided.") });
     }
+    /**
+     * Sets the output folder for generated reports.
+     * Use this when report files should land in a specific directory.
+     */
     WithReportFolder(reportFolderPath) {
         return this.withReportFolder(reportFolderPath);
     }
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     withReportingInterval(intervalSeconds) {
         if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) {
             throw new RangeError("Reporting interval should be greater than zero.");
         }
         return this.configure({ reportingIntervalSeconds: intervalSeconds });
     }
+    /**
+     * Sets the realtime reporting cadence.
+     * Use this when sinks or dashboards should receive updates at a controlled interval.
+     */
     WithReportingInterval(intervalSeconds) {
         return this.withReportingInterval(intervalSeconds);
     }
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     withClusterCommandTimeout(timeoutSeconds) {
         if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
             throw new RangeError("Cluster command timeout should be greater than zero.");
         }
         return this.configure({ clusterCommandTimeoutSeconds: timeoutSeconds });
     }
+    /**
+     * Sets the timeout for cluster command round-trips.
+     * Use this when distributed control messages need a tighter or looser deadline.
+     */
     WithClusterCommandTimeout(timeoutSeconds) {
         return this.withClusterCommandTimeout(timeoutSeconds);
     }
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     withRestartIterationMaxAttempts(attempts) {
         if (!Number.isFinite(attempts) || attempts < 0) {
             throw new RangeError("Restart iteration max attempts should be zero or greater.");
         }
         return this.configure({ restartIterationMaxAttempts: Math.trunc(attempts) });
     }
+    /**
+     * Sets the retry limit for restartable failed iterations.
+     * Use this when transient failures should be retried a fixed number of times.
+     */
     WithRestartIterationMaxAttempts(attempts) {
         return this.withRestartIterationMaxAttempts(attempts);
     }
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     withoutReports() {
         return this.configure({ reportsEnabled: false });
     }
+    /**
+     * Disables local report generation.
+     * Use this when reports are unnecessary or should be handled exclusively by sinks.
+     */
     WithoutReports() {
         return this.withoutReports();
     }
+    /**
+     * Builds the current configuration into a runnable context.
+     * Use this when you want to inspect or reuse the final run settings before execution.
+     */
     buildContext() {
         if (!this.scenarios.length) {
             throw new Error("At least one scenario must be added before building the runner context.");
@@ -1494,6 +2370,10 @@ export class LoadStrikeRunner {
         }
         return context;
     }
+    /**
+     * Builds the current configuration into a runnable context.
+     * Use this when you want to inspect or reuse the final run settings before execution.
+     */
     BuildContext() {
         return this.buildContext();
     }
@@ -1550,14 +2430,17 @@ export class LoadStrikeRunner {
         const selectedScenarios = clusterMode === "local-coordinator" || clusterMode === "nats-coordinator"
             ? await this.filterScenariosWithPolicies(this.scenarios, policies, policyErrors, runtimePolicyErrorMode)
             : await this.selectScenarios(policies, policyErrors, runtimePolicyErrorMode);
-        licensePayload = buildLicenseValidationPayload(this.options, this.scenarios);
+        if (clusterMode === "nats-agent") {
+            return this.runAgentWithNats(createdUtc, testInfo, nodeInfo);
+        }
+        licensePayload = buildLicenseValidationPayload({
+            ...this.options,
+            sessionId: testInfo.sessionId
+        }, this.scenarios);
         licenseClient = new LoadStrikeLocalClient({
             licenseValidationTimeoutMs: Math.max((this.options.licenseValidationTimeoutSeconds ?? 10) * 1000, 1)
         });
         licenseSession = await licenseClient.acquireLicenseLease(licensePayload);
-        if (clusterMode === "nats-agent") {
-            return this.runAgentWithNats(createdUtc, testInfo, nodeInfo);
-        }
         const loggerSetup = createLoggerSetup(this.options.loggerConfig, this.options.minimumLogLevel, this.options, testInfo, nodeInfo);
         const runLogger = loggerSetup.logger;
         const scenarioStartInfos = selectedScenarios.map((scenario, index) => {
@@ -1647,12 +2530,12 @@ export class LoadStrikeRunner {
             let result;
             let metricStats;
             if (clusterMode === "local-coordinator") {
-                const aggregated = await this.runCoordinatorWithLocalAgents(selectedScenarios, testInfo, nodeInfo);
+                const aggregated = await this.runCoordinatorWithLocalAgents(selectedScenarios, testInfo, nodeInfo, licenseClient, licenseSession);
                 metricStats = aggregated.metrics;
                 result = toDetailedRunResultFromNodeStats(aggregated, started.toISOString(), sinkErrors, policyErrors);
             }
             else if (clusterMode === "nats-coordinator") {
-                const aggregated = await this.runCoordinatorWithNats(selectedScenarios, testInfo, nodeInfo);
+                const aggregated = await this.runCoordinatorWithNats(selectedScenarios, testInfo, nodeInfo, licenseClient, licenseSession);
                 metricStats = aggregated.metrics;
                 result = toDetailedRunResultFromNodeStats(aggregated, started.toISOString(), sinkErrors, policyErrors);
             }
@@ -1799,8 +2682,8 @@ export class LoadStrikeRunner {
             natsServerUrl: undefined,
             reportFolderPath: resolve(this.options.reportFolderPath ?? "./reports", sanitizeReportFileName(machineName)),
             targetScenarios,
-            agentTargetScenarios: targetScenarios,
-            coordinatorTargetScenarios: [],
+            agentTargetScenarios: undefined,
+            coordinatorTargetScenarios: undefined,
             reportsEnabled: false,
             displayConsoleMetrics: false,
             reportingSinks: includeWorkerExtensions ? this.options.reportingSinks : [],
@@ -1818,16 +2701,40 @@ export class LoadStrikeRunner {
             logFiles: [...(childResult.logFiles ?? [])]
         };
     }
-    async runCoordinatorWithLocalAgents(scenarios, testInfo, nodeInfo) {
+    async runCoordinatorWithLocalAgents(scenarios, testInfo, nodeInfo, licenseClient, licenseSession) {
+        if (!licenseClient) {
+            throw new Error("Coordinator agent execution authorization requires an initialized licensing client.");
+        }
+        const controllerRunToken = stringValueOrDefault(licenseSession?.runToken, "").trim();
+        if (!controllerRunToken) {
+            throw new Error("Coordinator agent execution authorization requires an active controller run token.");
+        }
         const assignments = planRuntimeClusterAssignments(scenarios, Math.max(this.options.agentsCount ?? 1, 1), this.options.targetScenarios ?? [], this.options.agentTargetScenarios ?? []);
-        const nodeResults = await Promise.all(assignments.map((targetScenarios, index) => this.runClusterChildNode(targetScenarios, "Agent", `local-agent-${index + 1}`, false)));
+        const nodeResults = await Promise.all(assignments.map(async (targetScenarios, index) => {
+            const commandId = randomBytes(16).toString("hex");
+            const agentExecutionToken = await licenseClient.createAgentExecutionToken(controllerRunToken, testInfo.sessionId, commandId, index, assignments.length, targetScenarios);
+            return this.runClusterChildNode(targetScenarios, "Agent", `local-agent-${index + 1}`, false, {
+                sessionId: testInfo.sessionId,
+                testSuite: testInfo.testSuite,
+                testName: testInfo.testName,
+                agentCommandId: commandId,
+                agentExecutionToken
+            });
+        }));
         const coordinatorTargets = [...(this.options.coordinatorTargetScenarios ?? [])];
         if (coordinatorTargets.length) {
             nodeResults.push(await this.runClusterChildNode(coordinatorTargets, "Coordinator", nodeInfo.machineName, false));
         }
         return aggregateNodeStats(testInfo, { ...nodeInfo, nodeType: "Coordinator" }, nodeResults);
     }
-    async runCoordinatorWithNats(scenarios, testInfo, nodeInfo) {
+    async runCoordinatorWithNats(scenarios, testInfo, nodeInfo, licenseClient, licenseSession) {
+        if (!licenseClient) {
+            throw new Error("Coordinator agent execution authorization requires an initialized licensing client.");
+        }
+        const controllerRunToken = stringValueOrDefault(licenseSession?.runToken, "").trim();
+        if (!controllerRunToken) {
+            throw new Error("Coordinator agent execution authorization requires an active controller run token.");
+        }
         const assignments = planRuntimeClusterAssignments(scenarios, Math.max(this.options.agentsCount ?? 1, 1), this.options.targetScenarios ?? [], this.options.agentTargetScenarios ?? []);
         const coordinator = new DistributedClusterCoordinator({
             clusterId: this.options.clusterId ?? "local",
@@ -1841,7 +2748,7 @@ export class LoadStrikeRunner {
                 ? { ServerUrl: this.options.natsServerUrl }
                 : undefined
         });
-        const dispatch = await coordinator.dispatch(assignments);
+        const dispatch = await coordinator.dispatch(assignments, (command) => licenseClient.createAgentExecutionToken(controllerRunToken, testInfo.sessionId, command.commandId, command.agentIndex, command.agentCount, command.targetScenarios));
         const nodes = dispatch.nodeResults.map((value) => clusterNodeResultToNodeStats(value, testInfo, { ...nodeInfo, nodeType: "Agent" }));
         const coordinatorTargets = [...(this.options.coordinatorTargetScenarios ?? [])];
         if (coordinatorTargets.length) {
@@ -1871,7 +2778,9 @@ export class LoadStrikeRunner {
                     handledStats = await this.runClusterChildNode(dispatch.scenarioNames, "Agent", nodeInfo.machineName, true, {
                         sessionId: testInfo.sessionId,
                         testSuite: testInfo.testSuite,
-                        testName: testInfo.testName
+                        testName: testInfo.testName,
+                        agentCommandId: dispatch.commandId,
+                        agentExecutionToken: dispatch.agentRunToken
                     });
                     return {
                         nodeId: handledStats.nodeInfo.machineName,
@@ -6513,10 +7422,16 @@ function toRunContext(options) {
         RestartIterationMaxAttempts: normalized.restartIterationMaxAttempts,
         WorkerPlugins: normalized.workerPlugins,
         CustomSettings: normalized.customSettings,
-        GlobalCustomSettings: normalized.globalCustomSettings
+        GlobalCustomSettings: normalized.globalCustomSettings,
+        AgentExecutionToken: normalized.agentExecutionToken,
+        AgentCommandId: normalized.agentCommandId
     };
 }
 class RuntimePolicyCallbackError extends Error {
+    /**
+     * Exposes the public constructor operation.
+     * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.
+     */
     constructor(message) {
         super(message);
         this.name = "RuntimePolicyCallbackError";