@loadstrike/loadstrike-sdk 1.0.26901 → 1.0.27301

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 export { LoadStrikeAutopilot, LoadStrikeAutopilotResult } from "./autopilot.js";
 export { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
-export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeScenarioShare, LoadStrikeSimulation, LoadStrikeTrafficMix, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
+export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikeAccessibility, LoadStrikeAccessibilityAdapters, LoadStrikeAccessibilityBaseline, LoadStrikeAccessibilityCiGate, LoadStrikeAccessibilityScanner, LoadStrikeBrowserWebVitals, LoadStrikeBrowserWebVitalsCollector, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeScenarioShare, LoadStrikeSimulation, LoadStrikeTrafficMix, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
 export { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, InMemoryCorrelationStore, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingPayloadBuilder, TrackingFieldSelector } from "./correlation.js";
-export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
-export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, PortalReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
+export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, GrpcEndpointDefinition, GrpcMethodTypes, GrpcNativeClientOptions, GrpcStatusMapper, ProtocolMetricSnapshot, WebSocketEndpointDefinition, WebSocketExpectedMessage, WebSocketMessageSpec, WebSocketNativeClientOptions, WebSocketReconnectPolicy, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
+export { DatadogReportingSink, DatadogReportingSinkOptions, DogStatsDReportingSink, CloudWatchReportingSink, DynatraceReportingSink, ElasticsearchReportingSink, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, GenericWebhookReportingSink, InfluxDbReportingSink, InfluxDbReportingSinkOptions, JsonlFileReportingSink, KafkaReportingSink, NetdataStatsDReportingSink, NewRelicReportingSink, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, OpenSearchReportingSink, PortalReportingSink, PrometheusRemoteWriteReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, StatsDReportingSink, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";

package/dist/esm/local.js

@@ -40,7 +40,9 @@ const TRACKING_FEATURE_BY_KIND = {
     delegatestream: "endpoint.delegate_stream",
     nats: "endpoint.nats",
     redisstreams: "endpoint.redis_streams",
-    sqs: "endpoint.sqs"
+    sqs: "endpoint.sqs",
+    grpc: "endpoint.grpc",
+    websocket: "endpoint.websocket"
 };
 const CI_ENVIRONMENT_VARIABLES = [
     "GITHUB_ACTIONS",
@@ -166,7 +168,9 @@ export class LoadStrikeLocalClient {
             NodeType: stringOrDefault(context.NodeType, nodeType),
             MachineName: machineName,
             EnvironmentClassification: environmentClassification,
-            DeviceHash: computedDeviceHash
+            DeviceHash: computedDeviceHash,
+            Scenarios: buildLicenseScenarioMetadata(request),
+            ScenarioSourceAnalysis: buildScenarioSourceAnalysisMetadata(request)
         };
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), this.licenseValidationTimeoutMs);
@@ -1536,6 +1540,74 @@ function computeScenarioRequestCount(scenario) {
     }
     return Math.max(total, 0);
 }
+function buildLicenseScenarioMetadata(request) {
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    return scenarios.map((item) => {
+        const scenario = asRecord(item);
+        const scenarioName = stringOrDefault(scenario.ScenarioName ?? scenario.scenarioName ?? scenario.Name ?? scenario.name, "");
+        return {
+            Name: scenarioName,
+            ScenarioName: scenarioName,
+            Simulations: normalizeLicenseSimulations(scenario.LoadSimulations)
+        };
+    });
+}
+function normalizeLicenseSimulations(value) {
+    const simulations = Array.isArray(value) ? value : [];
+    return simulations.map((item) => {
+        const simulation = asRecord(item);
+        return {
+            Kind: stringOrDefault(simulation.Kind ?? simulation.kind, ""),
+            Rate: positiveOrUndefined(simulation.Rate ?? simulation.rate),
+            MinRate: positiveOrUndefined(simulation.MinRate ?? simulation.minRate),
+            MaxRate: positiveOrUndefined(simulation.MaxRate ?? simulation.maxRate),
+            Copies: positiveOrUndefined(simulation.Copies ?? simulation.copies),
+            Iterations: positiveOrUndefined(simulation.Iterations ?? simulation.iterations),
+            IntervalSeconds: positiveNumberOrUndefined(simulation.IntervalSeconds ?? simulation.intervalSeconds),
+            DurationSeconds: positiveNumberOrUndefined(simulation.DurationSeconds ?? simulation.durationSeconds ?? simulation.DuringSeconds ?? simulation.duringSeconds),
+            Children: normalizeLicenseSimulations(simulation.Children ?? simulation.children)
+        };
+    });
+}
+function buildScenarioSourceAnalysisMetadata(request) {
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    return scenarios.map((item) => {
+        const scenario = asRecord(item);
+        const source = asRecord(scenario.ScenarioSourceAnalysis ?? scenario.scenarioSourceAnalysis ?? scenario.SourceAnalysis);
+        const scenarioName = stringOrDefault(source.ScenarioName ?? source.scenarioName ?? scenario.Name ?? scenario.name, "");
+        const scenarioBlockLineCount = Math.max(asInt(source.ScenarioBlockLineCount ?? source.scenarioBlockLineCount), 1);
+        const localMethodLineCount = Math.max(asInt(source.LocalMethodLineCount
+            ?? source.localMethodLineCount
+            ?? source.TransitiveLocalMethodLineCount
+            ?? source.transitiveLocalMethodLineCount), 0);
+        const totalCountedLineCount = Math.max(asInt(source.TotalCountedLineCount ?? source.totalCountedLineCount), scenarioBlockLineCount + localMethodLineCount);
+        const warningsValue = source.Warnings ?? source.warnings;
+        const warnings = Array.isArray(warningsValue)
+            ? warningsValue.map((warning) => stringOrDefault(warning, "")).filter((warning) => warning.length > 0)
+            : ["Scenario source analysis was synthesized from scenario metadata."];
+        return {
+            ScenarioName: scenarioName,
+            Language: stringOrDefault(source.Language ?? source.language, "TypeScript/JavaScript"),
+            AnalyzerVersion: stringOrDefault(source.AnalyzerVersion ?? source.analyzerVersion, "function-source-v1"),
+            ScenarioBlockLineCount: scenarioBlockLineCount,
+            LocalMethodLineCount: localMethodLineCount,
+            TotalCountedLineCount: totalCountedLineCount,
+            IgnoredExternalCallCount: Math.max(asInt(source.IgnoredExternalCallCount
+                ?? source.ignoredExternalCallCount
+                ?? source.IgnoredLibraryCallCount
+                ?? source.ignoredLibraryCallCount), 0),
+            Warnings: warnings
+        };
+    });
+}
+function positiveOrUndefined(value) {
+    const normalized = asInt(value);
+    return normalized > 0 ? normalized : undefined;
+}
+function positiveNumberOrUndefined(value) {
+    const normalized = asNumber(value);
+    return normalized > 0 ? normalized : undefined;
+}
 function buildNodeStatsContract(context, createdUtc, completedUtc, values) {
     const durationMs = Math.max(completedUtc.getTime() - createdUtc.getTime(), 0);
     return {

package/dist/esm/runtime.js

@@ -1604,6 +1604,398 @@ 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 LoadStrikeAccessibilityBaseline {
+    constructor(initial = {}) {
+        const source = qualityRecord(initial);
+        this.allowedRuleIds = qualityStringArray(qualityValue(source, "allowedRuleIds", "AllowedRuleIds"));
+        this.AllowedRuleIds = this.allowedRuleIds;
+        this.maxNewViolations = Math.max(0, qualityNumber(source, 0, "maxNewViolations", "MaxNewViolations"));
+        this.MaxNewViolations = this.maxNewViolations;
+    }
+    compare(result) {
+        const violations = Array.isArray(result?.violations) ? result.violations : [];
+        const allowed = new Set(this.allowedRuleIds.map((value) => value.toLowerCase()));
+        const newViolations = violations.filter((violation) => !allowed.has(String(violation.ruleId ?? "").toLowerCase()));
+        const newRuleIds = Array.from(new Set(newViolations
+            .map((violation) => String(violation.ruleId ?? "").trim())
+            .filter(Boolean)));
+        return {
+            passed: newViolations.length <= this.maxNewViolations,
+            Passed: newViolations.length <= this.maxNewViolations,
+            newViolationCount: newViolations.length,
+            NewViolationCount: newViolations.length,
+            newRuleIds,
+            NewRuleIds: newRuleIds
+        };
+    }
+    Compare(result) {
+        return this.compare(result);
+    }
+}
+export class LoadStrikeAccessibilityCiGate {
+    constructor(initial = {}) {
+        const source = qualityRecord(initial);
+        this.maxViolations = qualityOptionalNumber(source, "maxViolations", "MaxViolations");
+        this.MaxViolations = this.maxViolations;
+        this.maxCriticalViolations = qualityOptionalNumber(source, "maxCriticalViolations", "MaxCriticalViolations");
+        this.MaxCriticalViolations = this.maxCriticalViolations;
+        this.maxSeriousViolations = qualityOptionalNumber(source, "maxSeriousViolations", "MaxSeriousViolations");
+        this.MaxSeriousViolations = this.maxSeriousViolations;
+        const baseline = qualityValue(source, "baseline", "Baseline");
+        this.baseline = baseline instanceof LoadStrikeAccessibilityBaseline
+            ? baseline
+            : (baseline && typeof baseline === "object" ? new LoadStrikeAccessibilityBaseline(baseline) : undefined);
+        this.Baseline = this.baseline;
+    }
+    evaluate(result) {
+        const normalized = attachAccessibilityCounts(result);
+        const reasons = [];
+        if (this.maxViolations != null && (normalized.totalViolations ?? 0) > this.maxViolations) {
+            reasons.push(`total accessibility violations ${normalized.totalViolations} exceeded ${this.maxViolations}.`);
+        }
+        if (this.maxCriticalViolations != null && (normalized.criticalViolations ?? 0) > this.maxCriticalViolations) {
+            reasons.push(`critical accessibility violations ${normalized.criticalViolations} exceeded ${this.maxCriticalViolations}.`);
+        }
+        if (this.maxSeriousViolations != null && (normalized.seriousViolations ?? 0) > this.maxSeriousViolations) {
+            reasons.push(`serious accessibility violations ${normalized.seriousViolations} exceeded ${this.maxSeriousViolations}.`);
+        }
+        if (this.baseline) {
+            const baseline = this.baseline.compare(normalized);
+            if (!baseline.passed) {
+                reasons.push(`baseline found ${baseline.newViolationCount} new accessibility violation(s).`);
+            }
+        }
+        return {
+            passed: reasons.length === 0,
+            Passed: reasons.length === 0,
+            reasons,
+            Reasons: reasons
+        };
+    }
+    Evaluate(result) {
+        return this.evaluate(result);
+    }
+}
+export class LoadStrikeAccessibilityScanner {
+    static scanHtml(options, html) {
+        validateAbsoluteUrl(options?.url, "Accessibility check URL");
+        const source = String(html ?? "");
+        const violations = [];
+        if (!/<html\b[^>]*\blang\s*=\s*["'][^"']+["']/i.test(source)) {
+            violations.push(createAccessibilityViolation("html-has-lang", "serious", "The html element should declare a non-empty language."));
+        }
+        if (/<title\b[^>]*>\s*<\/title>/i.test(source) || !/<title\b/i.test(source)) {
+            violations.push(createAccessibilityViolation("document-title", "serious", "The page should provide a useful title."));
+        }
+        for (const match of source.matchAll(/<img\b(?![^>]*\balt\s*=)[^>]*>/gi)) {
+            violations.push(createAccessibilityViolation("image-alt", "serious", "Images should provide alternate text.", match[0]));
+        }
+        for (const match of source.matchAll(/<button\b(?![^>]*\baria-label\s*=)[^>]*>\s*<\/button>/gi)) {
+            violations.push(createAccessibilityViolation("button-name", "critical", "Buttons should have an accessible name.", match[0]));
+        }
+        for (const match of source.matchAll(/<input\b(?![^>]*\baria-label\s*=)[^>]*\bid\s*=\s*["']?([a-zA-Z0-9_-]+)["']?[^>]*>/gi)) {
+            const id = match[1] ?? "";
+            const labelRegex = new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*["']?${escapeRegExp(id)}["']?[^>]*>`, "i");
+            if (!labelRegex.test(source)) {
+                violations.push(createAccessibilityViolation("label", "critical", "Form fields should have labels.", match[0]));
+            }
+        }
+        const focusOrder = [...source.matchAll(/<(a|button|input|select|textarea)\b[^>]*>/gi)]
+            .map((match) => match[0]);
+        const visibleFocusFailures = focusOrder.filter((element) => /outline\s*:\s*(none|0)\b/i.test(element)).length;
+        const missingSkipLinkCount = /href\s*=\s*["']#(main|content)["']/i.test(source) ? 0 : 1;
+        if (visibleFocusFailures > 0) {
+            violations.push(createAccessibilityViolation("focus-visible", "serious", "Keyboard focus indicators should remain visible."));
+        }
+        if (missingSkipLinkCount > 0) {
+            violations.push(createAccessibilityViolation("skip-link", "moderate", "Pages should provide a skip link to the main content."));
+        }
+        return attachAccessibilityCounts({
+            url: options.url,
+            violations,
+            keyboardFocus: {
+                tabbableElementCount: focusOrder.length,
+                visibleFocusFailures,
+                missingSkipLinkCount,
+                focusOrder
+            }
+        });
+    }
+    static ScanHtml(options, html) {
+        return LoadStrikeAccessibilityScanner.scanHtml(options, html);
+    }
+}
+export class LoadStrikeAccessibilityAdapters {
+    static async fromPlaywrightPageAsync(options, page) {
+        const html = await readBrowserContent(page, ["ContentAsync", "contentAsync", "content"]);
+        return LoadStrikeAccessibilityScanner.scanHtml(options, html);
+    }
+    static FromPlaywrightPageAsync(options, page) {
+        return LoadStrikeAccessibilityAdapters.fromPlaywrightPageAsync(options, page);
+    }
+    static fromSeleniumDriver(options, driver) {
+        const record = qualityRecord(driver);
+        const html = String(qualityValue(record, "PageSource", "pageSource") ?? "");
+        return LoadStrikeAccessibilityScanner.scanHtml(options, html);
+    }
+    static FromSeleniumDriver(options, driver) {
+        return LoadStrikeAccessibilityAdapters.fromSeleniumDriver(options, driver);
+    }
+}
+export class LoadStrikeBrowserWebVitalsCollector {
+    static fromPerformanceSnapshot(options, snapshot) {
+        validateAbsoluteUrl(options?.url, "Browser Web Vitals URL");
+        return normalizeWebVitalsSnapshot(options.url, snapshot);
+    }
+    static FromPerformanceSnapshot(options, snapshot) {
+        return LoadStrikeBrowserWebVitalsCollector.fromPerformanceSnapshot(options, snapshot);
+    }
+    static async fromPlaywrightPageAsync(options, page) {
+        validateAbsoluteUrl(options?.url, "Browser Web Vitals URL");
+        const snapshot = await invokeBrowserMethod(page, ["EvaluateAsync", "evaluate"], WEB_VITALS_SCRIPT);
+        return normalizeWebVitalsSnapshot(options.url, snapshot);
+    }
+    static FromPlaywrightPageAsync(options, page) {
+        return LoadStrikeBrowserWebVitalsCollector.fromPlaywrightPageAsync(options, page);
+    }
+    static fromSeleniumDriver(options, driver) {
+        validateAbsoluteUrl(options?.url, "Browser Web Vitals URL");
+        const snapshot = invokeBrowserMethodSync(driver, ["ExecuteScript", "executeScript"], WEB_VITALS_SCRIPT);
+        return normalizeWebVitalsSnapshot(options.url, snapshot);
+    }
+    static FromSeleniumDriver(options, driver) {
+        return LoadStrikeBrowserWebVitalsCollector.fromSeleniumDriver(options, driver);
+    }
+}
+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);
+    }
+}
+const WEB_VITALS_SCRIPT = `
+(() => {
+  const navigation = performance.getEntriesByType("navigation")[0];
+  const paint = performance.getEntriesByType("paint");
+  const fcp = paint.find((entry) => entry.name === "first-contentful-paint");
+  return {
+    largestContentfulPaintMs: globalThis.__loadstrikeLcp ?? 0,
+    interactionToNextPaintMs: globalThis.__loadstrikeInp ?? 0,
+    cumulativeLayoutShift: globalThis.__loadstrikeCls ?? 0,
+    firstContentfulPaintMs: fcp ? fcp.startTime : 0,
+    timeToFirstByteMs: navigation ? navigation.responseStart : 0
+  };
+})()
+`;
+function createAccessibilityViolation(ruleId, impact, description, target) {
+    return {
+        ruleId,
+        impact,
+        description,
+        helpUrl: `https://www.w3.org/WAI/WCAG22/quickref/?versions=2.2#${ruleId}`,
+        targets: target ? [target] : []
+    };
+}
+function attachAccessibilityCounts(result) {
+    const violations = Array.isArray(result?.violations) ? result.violations : [];
+    return {
+        ...result,
+        violations,
+        totalViolations: violations.length,
+        criticalViolations: countAccessibilityImpact(violations, "critical"),
+        seriousViolations: countAccessibilityImpact(violations, "serious"),
+        moderateViolations: countAccessibilityImpact(violations, "moderate"),
+        minorViolations: countAccessibilityImpact(violations, "minor")
+    };
+}
+function qualityRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function qualityValue(record, ...keys) {
+    for (const key of keys) {
+        if (key in record) {
+            return record[key];
+        }
+        const normalized = key.toLowerCase();
+        const match = Object.entries(record).find(([entryKey]) => entryKey.toLowerCase() === normalized);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+function qualityStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => String(entry ?? "").trim()).filter(Boolean);
+}
+function qualityNumber(record, fallback, ...keys) {
+    const value = qualityValue(record, ...keys);
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function qualityOptionalNumber(record, ...keys) {
+    const value = qualityValue(record, ...keys);
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function readBrowserContent(target, methodNames) {
+    const value = await invokeBrowserMethod(target, methodNames);
+    return String(value ?? "");
+}
+async function invokeBrowserMethod(target, methodNames, ...args) {
+    const record = qualityRecord(target);
+    for (const name of methodNames) {
+        const method = record[name];
+        if (typeof method === "function") {
+            return await method.apply(target, args);
+        }
+    }
+    throw new Error(`Browser object does not expose ${methodNames.join(" or ")}.`);
+}
+function invokeBrowserMethodSync(target, methodNames, ...args) {
+    const record = qualityRecord(target);
+    for (const name of methodNames) {
+        const method = record[name];
+        if (typeof method === "function") {
+            return method.apply(target, args);
+        }
+    }
+    throw new Error(`Browser object does not expose ${methodNames.join(" or ")}.`);
+}
+function normalizeWebVitalsSnapshot(url, snapshot) {
+    const source = qualityRecord(snapshot);
+    return {
+        url,
+        largestContentfulPaintMs: qualityNumber(source, 0, "largestContentfulPaintMs", "LargestContentfulPaintMs", "LCP", "lcp"),
+        interactionToNextPaintMs: qualityNumber(source, 0, "interactionToNextPaintMs", "InteractionToNextPaintMs", "INP", "inp"),
+        cumulativeLayoutShift: qualityNumber(source, 0, "cumulativeLayoutShift", "CumulativeLayoutShift", "CLS", "cls"),
+        firstContentfulPaintMs: qualityNumber(source, 0, "firstContentfulPaintMs", "FirstContentfulPaintMs", "FCP", "fcp"),
+        timeToFirstByteMs: qualityNumber(source, 0, "timeToFirstByteMs", "TimeToFirstByteMs", "TTFB", "ttfb")
+    };
+}
+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;
@@ -1838,6 +2230,26 @@ export class LoadStrikeScenario {
     __loadStrikeInternalLicenseFeatures() {
         return [...this.internalLicenseFeatures];
     }
+    __loadStrikeScenarioSourceAnalysis() {
+        const source = this.runHandler.toString();
+        const lines = source
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("//"));
+        const lineCount = Math.max(lines.length, 1);
+        return {
+            ScenarioName: this.name,
+            Language: "TypeScript/JavaScript",
+            AnalyzerVersion: "function-source-v1",
+            ScenarioBlockLineCount: lineCount,
+            LocalMethodLineCount: 0,
+            TotalCountedLineCount: lineCount,
+            IgnoredExternalCallCount: 0,
+            Warnings: [
+                "Function-source analysis counts the scenario handler source available at runtime; imported library implementation lines are ignored."
+            ]
+        };
+    }
     __loadStrikeWithInternalLicenseFeatures(...features) {
         const merged = Array.from(new Set([...this.internalLicenseFeatures, ...normalizeStringArray(features)]));
         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, this.restartIterationOnFail, merged);
@@ -7931,7 +8343,8 @@ function buildLicenseValidationPayload(options, scenarios) {
             Weight: scenario.getWeight(),
             LoadSimulations: [...scenario.getSimulations()],
             Thresholds: [...scenario.getThresholds()],
-            Tracking: scenario.getTrackingConfiguration() ?? {}
+            Tracking: scenario.getTrackingConfiguration() ?? {},
+            ScenarioSourceAnalysis: scenario.__loadStrikeScenarioSourceAnalysis()
         };
         const internalLicenseFeatures = scenario.__loadStrikeInternalLicenseFeatures();
         if (internalLicenseFeatures.length > 0) {