@loadstrike/loadstrike-sdk 1.0.26701 → 1.0.27101

package/dist/esm/runtime.js

@@ -69,6 +69,7 @@ export const CrossPlatformTrackingConfiguration = {
         return this.forDuration(configuration, durationSeconds, cancellationSignal);
     }
 };
+const TRAFFIC_MIX_FEATURE = "workload.traffic_mix";
 export class LoadStrikePluginDataTable {
     /**
      * Exposes the public constructor operation.
@@ -1603,6 +1604,112 @@ export class LoadStrikeContext {
         return this.assignState(this.values, scenarios, this.runArgs);
     }
 }
+const ACCESSIBILITY_TESTING_FEATURE = "testing.accessibility";
+const BROWSER_WEB_VITALS_FEATURE = "testing.browser_web_vitals";
+export class LoadStrikeAccessibility {
+    static createScenario(name, options, check) {
+        if (typeof name !== "string" || !name.trim()) {
+            throw new Error("Scenario name must be provided.");
+        }
+        validateAbsoluteUrl(options?.url, "Accessibility check URL");
+        if (typeof check !== "function") {
+            throw new TypeError("Accessibility check callback must be provided.");
+        }
+        return LoadStrikeScenario
+            .create(name, async (scenarioContext) => {
+            const result = await check({ options, scenarioContext });
+            const failure = evaluateAccessibilityResult(options, result);
+            return failure
+                ? LoadStrikeResponse.fail("accessibility", failure)
+                : LoadStrikeResponse.ok("200", 0, `Accessibility check passed with ${(result.violations ?? []).length} violation(s).`);
+        })
+            .withoutWarmUp()
+            .__loadStrikeWithInternalLicenseFeatures(ACCESSIBILITY_TESTING_FEATURE);
+    }
+    static CreateScenario(name, options, check) {
+        return LoadStrikeAccessibility.createScenario(name, options, check);
+    }
+}
+export class LoadStrikeBrowserWebVitals {
+    static createScenario(name, options, measure) {
+        if (typeof name !== "string" || !name.trim()) {
+            throw new Error("Scenario name must be provided.");
+        }
+        validateAbsoluteUrl(options?.url, "Browser Web Vitals URL");
+        if (typeof measure !== "function") {
+            throw new TypeError("Browser Web Vitals measurement callback must be provided.");
+        }
+        return LoadStrikeScenario
+            .create(name, async (scenarioContext) => {
+            const result = await measure({ options, scenarioContext });
+            const failure = evaluateWebVitalsResult(options, result);
+            return failure
+                ? LoadStrikeResponse.fail("web_vitals", failure)
+                : LoadStrikeResponse.ok("200", 0, "Browser Web Vitals check passed.");
+        })
+            .withoutWarmUp()
+            .__loadStrikeWithInternalLicenseFeatures(BROWSER_WEB_VITALS_FEATURE);
+    }
+    static CreateScenario(name, options, measure) {
+        return LoadStrikeBrowserWebVitals.createScenario(name, options, measure);
+    }
+}
+function validateAbsoluteUrl(value, label) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${label} must be provided.`);
+    }
+    try {
+        const parsed = new URL(value);
+        if (!parsed.protocol || !parsed.host) {
+            throw new Error("invalid");
+        }
+    }
+    catch {
+        throw new Error(`${label} must be an absolute URL.`);
+    }
+}
+function evaluateAccessibilityResult(options, result) {
+    if (!result) {
+        return "Accessibility check did not return a result.";
+    }
+    const violations = Array.isArray(result.violations) ? result.violations : [];
+    const maxViolations = Math.max(0, Number(options.maxViolations ?? 0));
+    const critical = countAccessibilityImpact(violations, "critical");
+    const serious = countAccessibilityImpact(violations, "serious");
+    const maxCritical = Math.max(0, Number(options.maxCriticalViolations ?? 0));
+    const maxSerious = Math.max(0, Number(options.maxSeriousViolations ?? 0));
+    if (violations.length > maxViolations) {
+        return `Accessibility violations ${violations.length} exceeded limit ${maxViolations}.`;
+    }
+    if (critical > maxCritical) {
+        return `Critical accessibility violations ${critical} exceeded limit ${maxCritical}.`;
+    }
+    if (serious > maxSerious) {
+        return `Serious accessibility violations ${serious} exceeded limit ${maxSerious}.`;
+    }
+    return "";
+}
+function countAccessibilityImpact(violations, impact) {
+    return violations.filter((violation) => String(violation.impact ?? "").toLowerCase() === impact).length;
+}
+function evaluateWebVitalsResult(options, result) {
+    if (!result) {
+        return "Browser Web Vitals check did not return a result.";
+    }
+    return firstWebVitalViolation(["LCP", result.largestContentfulPaintMs, options.maxLargestContentfulPaintMs, "ms"], ["INP", result.interactionToNextPaintMs, options.maxInteractionToNextPaintMs, "ms"], ["CLS", result.cumulativeLayoutShift, options.maxCumulativeLayoutShift, ""], ["FCP", result.firstContentfulPaintMs, options.maxFirstContentfulPaintMs, "ms"], ["TTFB", result.timeToFirstByteMs, options.maxTimeToFirstByteMs, "ms"]);
+}
+function firstWebVitalViolation(...values) {
+    for (const [name, actualRaw, limitRaw, unit] of values) {
+        const actual = Number(actualRaw);
+        const limit = Number(limitRaw);
+        if (!Number.isFinite(actual) || !Number.isFinite(limit) || actual <= limit) {
+            continue;
+        }
+        const suffix = unit ? ` ${unit}` : "";
+        return `${name} ${actual}${suffix} exceeded limit ${limit}${suffix}.`;
+    }
+    return "";
+}
 export class LoadStrikeScenario {
     constructor(name, runHandler, initHandler, cleanHandler, loadSimulations, thresholds, trackingConfiguration, maxFailCount, withoutWarmUpValue, warmUpDurationSeconds, weight, restartIterationOnFail, internalLicenseFeatures = []) {
         this.name = name;
@@ -1948,6 +2055,103 @@ export class LoadStrikeScenario {
         return this.withWeight(weight);
     }
 }
+export class LoadStrikeScenarioShare {
+    constructor(scenario, weight) {
+        this.scenario = scenario;
+        this.weight = weight;
+    }
+    /**
+     * Creates a weighted scenario lane for a traffic mix.
+     * Use this when a total workload should be distributed across several scenarios.
+     */
+    static create(scenario, weight) {
+        if (!(scenario instanceof LoadStrikeScenario)) {
+            throw new TypeError("Scenario must be provided.");
+        }
+        const normalizedWeight = Math.trunc(weight);
+        if (!Number.isFinite(weight) || normalizedWeight <= 0) {
+            throw new RangeError("Scenario share weight should be greater than zero.");
+        }
+        return new LoadStrikeScenarioShare(scenario, normalizedWeight);
+    }
+    /**
+     * Creates a weighted scenario lane for a traffic mix.
+     * Use this when a total workload should be distributed across several scenarios.
+     */
+    static Create(scenario, weight) {
+        return LoadStrikeScenarioShare.create(scenario, weight);
+    }
+}
+export class LoadStrikeTrafficMix {
+    constructor(name, totalLoad = [], scenarioMix = []) {
+        this.name = name;
+        this.totalLoad = totalLoad.map((simulation) => attachLoadSimulationProjection({ ...simulation }));
+        this.scenarioMix = [...scenarioMix];
+    }
+    /**
+     * Creates a traffic mix definition.
+     * Use this when one total load profile should be split across multiple scenario lanes.
+     */
+    static create(name) {
+        return new LoadStrikeTrafficMix(requireNonEmpty(name, "Traffic mix name must be provided."));
+    }
+    /**
+     * Creates a traffic mix definition.
+     * Use this when one total load profile should be split across multiple scenario lanes.
+     */
+    static Create(name) {
+        return LoadStrikeTrafficMix.create(name);
+    }
+    /**
+     * Sets the total workload shape for the mix.
+     * Use this when the same high-level load profile should be distributed by scenario weights.
+     */
+    withTotalLoad(...totalLoad) {
+        if (!totalLoad.length) {
+            throw new Error("At least one total load simulation should be provided.");
+        }
+        return new LoadStrikeTrafficMix(this.name, totalLoad, this.scenarioMix);
+    }
+    /**
+     * Sets the total workload shape for the mix.
+     * Use this when the same high-level load profile should be distributed by scenario weights.
+     */
+    WithTotalLoad(...totalLoad) {
+        return this.withTotalLoad(...totalLoad);
+    }
+    /**
+     * Sets the weighted scenario lanes for the mix.
+     * Use this when each operation should receive a fixed proportion of the total workload.
+     */
+    withScenarioMix(...scenarioMix) {
+        if (!scenarioMix.length) {
+            throw new Error("At least one scenario share should be provided.");
+        }
+        if (scenarioMix.some((share) => !(share instanceof LoadStrikeScenarioShare))) {
+            throw new TypeError("Scenario share collection cannot contain null values.");
+        }
+        return new LoadStrikeTrafficMix(this.name, this.totalLoad, scenarioMix);
+    }
+    /**
+     * Sets the weighted scenario lanes for the mix.
+     * Use this when each operation should receive a fixed proportion of the total workload.
+     */
+    WithScenarioMix(...scenarioMix) {
+        return this.withScenarioMix(...scenarioMix);
+    }
+    expandScenarios() {
+        return expandTrafficMixScenarios(this);
+    }
+    ExpandScenarios() {
+        return this.expandScenarios();
+    }
+    __loadStrikeTotalLoad() {
+        return this.totalLoad.map((simulation) => attachLoadSimulationProjection({ ...simulation }));
+    }
+    __loadStrikeScenarioMix() {
+        return [...this.scenarioMix];
+    }
+}
 export class LoadStrikeRunner {
     constructor(scenarios, options, contextConfigurators = []) {
         this.scenarios = scenarios;
@@ -1983,6 +2187,20 @@ export class LoadStrikeRunner {
     static RegisterScenarios(...scenarios) {
         return LoadStrikeRunner.registerScenarios(...scenarios);
     }
+    /**
+     * Registers a traffic mix on a fresh runnable context.
+     * Use this when one total load profile should be split across weighted scenario lanes.
+     */
+    static registerTrafficMix(trafficMix) {
+        return LoadStrikeRunner.registerScenarios(...expandTrafficMixScenarios(trafficMix));
+    }
+    /**
+     * Registers a traffic mix on a fresh runnable context.
+     * Use this when one total load profile should be split across weighted scenario lanes.
+     */
+    static RegisterTrafficMix(trafficMix) {
+        return LoadStrikeRunner.registerTrafficMix(trafficMix);
+    }
     /**
      * Toggles realtime console metric output.
      * Use this when a local run or CI log should stream live throughput and latency updates.
@@ -2237,6 +2455,21 @@ export class LoadStrikeRunner {
     AddScenarios(...scenarios) {
         return this.addScenarios(...scenarios);
     }
+    /**
+     * Adds a traffic mix to the current runner.
+     * Use this when one total load profile should be split across weighted scenario lanes.
+     */
+    addTrafficMix(trafficMix) {
+        this.scenarios = [...this.scenarios, ...expandTrafficMixScenarios(trafficMix)];
+        return this;
+    }
+    /**
+     * Adds a traffic mix to the current runner.
+     * Use this when one total load profile should be split across weighted scenario lanes.
+     */
+    AddTrafficMix(trafficMix) {
+        return this.addTrafficMix(trafficMix);
+    }
     /**
      * Applies a grouped configuration change to the current builder or context.
      * Use this when several related settings should be supplied in one step.
@@ -4388,6 +4621,111 @@ function attachLoadSimulationProjection(simulation) {
     });
     return simulation;
 }
+function expandTrafficMixScenarios(trafficMix) {
+    if (!(trafficMix instanceof LoadStrikeTrafficMix)) {
+        throw new TypeError("Traffic mix must be provided.");
+    }
+    const totalLoad = trafficMix.__loadStrikeTotalLoad();
+    if (!totalLoad.length) {
+        throw new Error("Traffic mix total load must be configured before registration.");
+    }
+    const scenarioMix = trafficMix.__loadStrikeScenarioMix();
+    if (!scenarioMix.length) {
+        throw new Error("Traffic mix scenario shares must be configured before registration.");
+    }
+    const weights = scenarioMix.map((share) => share.weight);
+    return scenarioMix.map((share, index) => {
+        const splitSimulations = totalLoad
+            .map((simulation) => splitTrafficSimulation(simulation, weights, index))
+            .filter((simulation) => simulation != null);
+        const scenario = !splitSimulations.length
+            ? share.scenario.withLoadSimulations(LoadStrikeSimulation.pause(0))
+            : share.scenario.withLoadSimulations(...splitSimulations);
+        return scenario.__loadStrikeWithInternalLicenseFeatures(TRAFFIC_MIX_FEATURE);
+    });
+}
+function splitTrafficSimulation(simulation, weights, index) {
+    const kind = String(simulation.Kind ?? "");
+    const duringSeconds = readFiniteSimulationNumber(simulation, "DuringSeconds");
+    const intervalSeconds = readFiniteSimulationNumber(simulation, "IntervalSeconds");
+    if (kind === "Inject") {
+        const rate = splitTrafficValue(readFiniteSimulationNumber(simulation, "Rate"), weights)[index];
+        return rate > 0 ? LoadStrikeSimulation.inject(rate, intervalSeconds, duringSeconds) : null;
+    }
+    if (kind === "RampingInject") {
+        const rate = splitTrafficValue(readFiniteSimulationNumber(simulation, "Rate"), weights)[index];
+        return rate > 0 ? LoadStrikeSimulation.rampingInject(rate, intervalSeconds, duringSeconds) : null;
+    }
+    if (kind === "InjectRandom") {
+        const minRate = splitTrafficValue(readFiniteSimulationNumber(simulation, "MinRate"), weights)[index];
+        const maxRate = splitTrafficValue(readFiniteSimulationNumber(simulation, "MaxRate"), weights)[index];
+        if (maxRate <= 0) {
+            return null;
+        }
+        return LoadStrikeSimulation.injectRandom(Math.min(minRate, maxRate), maxRate, intervalSeconds, duringSeconds);
+    }
+    if (kind === "IterationsForInject") {
+        const rate = splitTrafficValue(readFiniteSimulationNumber(simulation, "Rate"), weights)[index];
+        const iterations = splitTrafficValue(readFiniteSimulationNumber(simulation, "Iterations"), weights)[index];
+        return rate > 0 && iterations > 0
+            ? LoadStrikeSimulation.iterationsForInject(rate, intervalSeconds, iterations)
+            : null;
+    }
+    if (kind === "IterationsForConstant") {
+        const copies = splitTrafficValue(readFiniteSimulationNumber(simulation, "Copies"), weights)[index];
+        const iterations = splitTrafficValue(readFiniteSimulationNumber(simulation, "Iterations"), weights)[index];
+        return copies > 0 && iterations > 0
+            ? LoadStrikeSimulation.iterationsForConstant(copies, iterations)
+            : null;
+    }
+    if (kind === "KeepConstant") {
+        const copies = splitTrafficValue(readFiniteSimulationNumber(simulation, "Copies"), weights)[index];
+        return copies > 0 ? LoadStrikeSimulation.keepConstant(copies, duringSeconds) : null;
+    }
+    if (kind === "RampingConstant") {
+        const copies = splitTrafficValue(readFiniteSimulationNumber(simulation, "Copies"), weights)[index];
+        return copies > 0 ? LoadStrikeSimulation.rampingConstant(copies, duringSeconds) : null;
+    }
+    if (kind === "Pause") {
+        return LoadStrikeSimulation.pause(duringSeconds);
+    }
+    return attachLoadSimulationProjection({ ...simulation });
+}
+function splitTrafficValue(totalValue, weights) {
+    const normalizedTotal = Math.trunc(Number.isFinite(totalValue) ? totalValue : 0);
+    if (normalizedTotal <= 0) {
+        return weights.map(() => 0);
+    }
+    const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+    if (totalWeight <= 0) {
+        throw new Error("Traffic mix scenario weights must add up to more than zero.");
+    }
+    const exactShares = weights.map((weight, index) => {
+        const exact = (normalizedTotal * weight) / totalWeight;
+        return {
+            index,
+            value: Math.floor(exact),
+            remainder: exact - Math.floor(exact)
+        };
+    });
+    const split = exactShares.map((share) => share.value);
+    let remaining = normalizedTotal - split.reduce((sum, value) => sum + value, 0);
+    for (const share of [...exactShares].sort((left, right) => {
+        const remainderDelta = right.remainder - left.remainder;
+        return remainderDelta !== 0 ? remainderDelta : left.index - right.index;
+    })) {
+        if (remaining <= 0) {
+            break;
+        }
+        split[share.index] += 1;
+        remaining -= 1;
+    }
+    return split;
+}
+function readFiniteSimulationNumber(simulation, key) {
+    const value = Number(simulation[key]);
+    return Number.isFinite(value) ? value : 0;
+}
 function attachScenarioStatsAliases(scenario) {
     const normalized = normalizeScenarioStatsValue(scenario);
     normalized.ok = attachMeasurementStatsAliases(normalized.ok);
@@ -8346,6 +8684,7 @@ export const __loadstrikeTestExports = {
     detailedToNodeStats,
     evaluateThresholdsForScenarios,
     executeTrackedScenarioInvocation,
+    expandTrafficMixScenarios,
     extractContextOverridesFromArgs,
     extractContextOverridesFromConfig,
     findCaseInsensitiveKey,