@loadstrike/loadstrike-sdk 1.0.21101 → 1.0.21401

package/dist/esm/autopilot.js

@@ -0,0 +1,709 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LoadStrikeAutopilotResult_httpRequest;
+import fs from "node:fs";
+import { LoadStrikeResponse, LoadStrikeScenario, LoadStrikeSimulation, LoadStrikeThreshold } from "./runtime.js";
+import { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
+const REDACTED = "[REDACTED]";
+const ENV_MARKER_PREFIX = "${LOADSTRIKE_ENV:";
+const ENV_MARKER_SUFFIX = "}";
+const TRACE_TO_TEST_AUTOPILOT_FEATURE = "autopilot.trace_to_test";
+const SECRET_KEYS = new Set([
+    "authorization",
+    "proxy_authorization",
+    "proxy-authorization",
+    "cookie",
+    "set_cookie",
+    "set-cookie",
+    "x_api_key",
+    "x-api-key",
+    "token",
+    "access_token",
+    "refresh_token",
+    "password",
+    "secret",
+    "client_secret",
+    "api_key",
+    "apikey"
+]);
+export class LoadStrikeAutopilotResult {
+    constructor(values) {
+        _LoadStrikeAutopilotResult_httpRequest.set(this, void 0);
+        this.Readiness = values.readiness;
+        this.Plan = values.plan;
+        this.Endpoints = values.endpoints;
+        this.Redactions = values.redactions;
+        this.Warnings = values.warnings;
+        this.ReadinessFailures = values.readinessFailures;
+        this.PreviewReport = undefined;
+        this.ObservedLatencyMs = values.observedLatencyMs;
+        __classPrivateFieldSet(this, _LoadStrikeAutopilotResult_httpRequest, values.httpRequest, "f");
+    }
+    buildScenario() {
+        if (this.Readiness !== LoadStrikeAutopilotReadiness.Ready) {
+            throw new Error(`Autopilot result is not ready to build a scenario. Current readiness: ${this.Readiness}.`);
+        }
+        if (!__classPrivateFieldGet(this, _LoadStrikeAutopilotResult_httpRequest, "f")) {
+            throw new Error("Autopilot result does not contain a runnable HTTP request.");
+        }
+        const request = resolveHttpRequestSecrets(__classPrivateFieldGet(this, _LoadStrikeAutopilotResult_httpRequest, "f"));
+        let scenario = LoadStrikeScenario
+            .create(this.Plan.Scenario.Name || "autopilot-starter", async () => {
+            try {
+                const response = await fetch(request.url, {
+                    method: request.method,
+                    headers: request.headers,
+                    body: request.body
+                });
+                const body = await response.arrayBuffer();
+                const statusCode = String(response.status);
+                return response.ok
+                    ? LoadStrikeResponse.ok(statusCode, body.byteLength)
+                    : LoadStrikeResponse.fail(statusCode, `HTTP replay returned ${statusCode}.`, body.byteLength);
+            }
+            catch (error) {
+                return LoadStrikeResponse.fail("autopilot_http_error", error instanceof Error ? error.message : String(error));
+            }
+        })
+            .withoutWarmUp()
+            .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(1, 1));
+        const thresholds = this.Plan.ThresholdSuggestions.map(compileThreshold);
+        if (thresholds.length > 0) {
+            scenario = scenario.withThresholds(...thresholds);
+        }
+        return scenario.__loadStrikeWithInternalLicenseFeatures(TRACE_TO_TEST_AUTOPILOT_FEATURE);
+    }
+    BuildScenario() {
+        return this.buildScenario();
+    }
+}
+_LoadStrikeAutopilotResult_httpRequest = new WeakMap();
+export class LoadStrikeAutopilot {
+    static generate(request) {
+        const artifact = loadAutopilotArtifact(request);
+        const options = request.Options ?? {};
+        const result = inferAutopilotResult(artifact, options);
+        if (options.IncludePreviewReport) {
+            result.PreviewReport = buildPreviewReport(result);
+        }
+        return result;
+    }
+    static Generate(request) {
+        return LoadStrikeAutopilot.generate(request);
+    }
+}
+function loadAutopilotArtifact(request) {
+    if (!request || typeof request.Kind !== "string" || !request.Kind.trim()) {
+        throw new Error("Autopilot kind must be provided.");
+    }
+    if (equalsKind(request.Kind, "MessagePair")) {
+        return {
+            kind: request.Kind,
+            sourceMessage: request.SourceMessage,
+            destinationMessage: request.DestinationMessage
+        };
+    }
+    let content = request.Content;
+    if ((!content || !content.trim()) && request.FilePath) {
+        content = fs.readFileSync(request.FilePath, "utf8");
+    }
+    if (!content || !content.trim()) {
+        throw new Error("Autopilot content or file path must be provided.");
+    }
+    try {
+        return { kind: request.Kind, root: JSON.parse(content) };
+    }
+    catch {
+        throw new Error(`Autopilot ${request.Kind} artifact is invalid JSON.`);
+    }
+}
+function inferAutopilotResult(artifact, options) {
+    if (equalsKind(artifact.kind, "Har")) {
+        return fromHar(artifact, options);
+    }
+    if (equalsKind(artifact.kind, "OtelTrace")) {
+        return fromOtelTrace(artifact, options);
+    }
+    if (equalsKind(artifact.kind, "PlaywrightRecording")) {
+        return fromPlaywrightRecording(artifact, options);
+    }
+    if (equalsKind(artifact.kind, "MessagePair")) {
+        return fromMessagePair(artifact, options);
+    }
+    throw new Error(`Unsupported Autopilot kind '${artifact.kind}'.`);
+}
+function fromHar(artifact, options) {
+    const root = asRecord(artifact.root);
+    const entries = asArray(asRecord(root.log).entries);
+    if (entries.length === 0) {
+        return buildReviewResult(options, "HAR artifact does not contain any entries.");
+    }
+    const entry = asRecord(entries[0]);
+    const request = asRecord(entry.request);
+    const url = asString(request.url);
+    if (!url) {
+        return buildReviewResult(options, "HAR request does not contain a URL.");
+    }
+    const headers = {};
+    for (const header of asArray(request.headers)) {
+        const item = asRecord(header);
+        const name = asString(item.name);
+        if (name) {
+            headers[name] = asString(item.value) ?? "";
+        }
+    }
+    const postData = asRecord(request.postData);
+    return buildHttpResult(options, {
+        method: asString(request.method) ?? "GET",
+        url,
+        headers,
+        body: asString(postData.text),
+        contentType: headerValue(headers, "content-type") ?? asString(postData.mimeType),
+        observedLatencyMs: asNumber(entry.time)
+    });
+}
+function fromOtelTrace(artifact, options) {
+    const span = findFirstSpan(asRecord(artifact.root));
+    if (!span) {
+        return buildReviewResult(options, "OpenTelemetry artifact does not contain any spans.");
+    }
+    const attributes = readOtelAttributes(span);
+    const url = attributes["url.full"] ?? attributes["http.url"];
+    if (!url) {
+        return buildReviewResult(options, "OpenTelemetry span does not contain an HTTP URL.");
+    }
+    const headers = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        const prefix = "http.request.header.";
+        if (key.toLowerCase().startsWith(prefix)) {
+            headers[key.slice(prefix.length)] = value;
+        }
+    }
+    return buildHttpResult(options, {
+        method: attributes["http.request.method"] ?? attributes["http.method"] ?? "GET",
+        url,
+        headers,
+        observedLatencyMs: readSpanDurationMs(span)
+    });
+}
+function fromPlaywrightRecording(artifact, options) {
+    const network = asArray(asRecord(artifact.root).network);
+    if (network.length === 0) {
+        return buildReviewResult(options, "Playwright recording does not contain any network entries.");
+    }
+    const entry = asRecord(network[0]);
+    const url = asString(entry.url);
+    if (!url) {
+        return buildReviewResult(options, "Playwright network entry does not contain a URL.");
+    }
+    const headers = Object.fromEntries(Object.entries(asRecord(entry.requestHeaders)).map(([key, value]) => [key, String(value)]));
+    const body = entry.requestBody == null
+        ? undefined
+        : typeof entry.requestBody === "string" ? entry.requestBody : JSON.stringify(entry.requestBody);
+    return buildHttpResult(options, {
+        method: asString(entry.method) ?? "GET",
+        url,
+        headers,
+        body,
+        contentType: headerValue(headers, "content-type"),
+        observedLatencyMs: asNumber(entry.durationMs)
+    });
+}
+function fromMessagePair(artifact, options) {
+    const source = artifact.sourceMessage;
+    const destination = artifact.destinationMessage;
+    if (!source || !destination) {
+        return buildReviewResult(options, "MessagePair input requires both source and destination messages.");
+    }
+    const inferredSelector = findSharedHeaderSelector(readHeaders(source), readHeaders(destination));
+    const selector = inferredSelector ?? options.TrackingSelector?.trim();
+    const { endpoints, missing } = applyEndpointBindings([
+        { Kind: "DelegateStream", Name: source.name ?? source.Name ?? "source" },
+        { Kind: "DelegateStream", Name: destination.name ?? destination.Name ?? "destination" }
+    ], options.EndpointBindings ?? []);
+    const failures = [];
+    if (!selector) {
+        failures.push(readinessFailure(LoadStrikeAutopilotReadiness.RequiresTrackingSelector, "No stable shared tracking ID was found across the source and destination messages.", "TrackingSelector"));
+    }
+    if (missing.length > 0) {
+        failures.push(readinessFailure(LoadStrikeAutopilotReadiness.RequiresEndpointBinding, "Message pair input requires explicit endpoint binding before it can run.", "EndpointBindings", missing));
+    }
+    if (failures.length === 0) {
+        failures.push(readinessFailure(LoadStrikeAutopilotReadiness.RequiresReview, "Message pair endpoint bindings were supplied, but automatic runnable scenario generation currently supports HTTP replay artifacts only.", "ManualReview"));
+    }
+    const readiness = failures[0].Readiness;
+    return buildResult({
+        readiness,
+        options,
+        endpoints,
+        trackingSuggestions: selector ? [{ Expression: selector, Confidence: inferredSelector ? 0.9 : 1 }] : [],
+        thresholdSuggestions: seedThresholds(undefined),
+        redactions: [],
+        warnings: failures.map((failure) => failure.Reason),
+        readinessFailures: failures,
+        confidence: 0.7
+    });
+}
+function buildHttpResult(options, input) {
+    const redactions = [];
+    const secretBindings = secretBindingMap(options.SecretBindings ?? []);
+    const unresolvedSecretLocations = [];
+    const headers = redactHeaders(input.headers, redactions, secretBindings, (location) => {
+        unresolvedSecretLocations.push(location);
+    });
+    const body = redactBody(input.body, redactions, secretBindings, (location) => {
+        unresolvedSecretLocations.push(location);
+    });
+    const url = redactUrl(input.url, redactions, secretBindings, (location) => {
+        unresolvedSecretLocations.push(location);
+    });
+    const target = resolveReplayUrl(url, options);
+    const selector = inferTrackingSelector(headers, body) ?? options.TrackingSelector?.trim();
+    const failures = [];
+    if (unresolvedSecretLocations.length > 0) {
+        failures.push(readinessFailure(LoadStrikeAutopilotReadiness.RequiresSecrets, "Secret bindings are required for every redacted header, query parameter, or body field before replay can run.", "SecretBindings", unresolvedSecretLocations));
+    }
+    if (!target.ready) {
+        failures.push(readinessFailure(LoadStrikeAutopilotReadiness.RequiresTargetBinding, target.warning ?? "Captured target requires explicit replay binding before replay can run.", "AllowedReplayHosts|BaseUrlRewrite|EndpointBindings[source-http]", ["source-http"]));
+    }
+    if (!selector) {
+        failures.push(readinessFailure(LoadStrikeAutopilotReadiness.RequiresTrackingSelector, "No stable tracking selector could be inferred from the artifact.", "TrackingSelector"));
+    }
+    const readiness = failures.length === 0 ? LoadStrikeAutopilotReadiness.Ready : failures[0].Readiness;
+    const warnings = failures.map((failure) => failure.Reason);
+    const endpoints = [{
+            Kind: "Http",
+            Name: "source-http",
+            Method: input.method.toUpperCase(),
+            Url: target.url
+        }];
+    return buildResult({
+        readiness,
+        options,
+        endpoints,
+        trackingSuggestions: selector ? [{ Expression: selector, Confidence: 0.9 }] : [],
+        thresholdSuggestions: seedThresholds(input.observedLatencyMs),
+        redactions,
+        warnings,
+        readinessFailures: failures,
+        httpRequest: readiness === LoadStrikeAutopilotReadiness.Ready ? {
+            method: input.method.toUpperCase(),
+            url: target.url,
+            headers,
+            body,
+            contentType: input.contentType
+        } : undefined,
+        observedLatencyMs: input.observedLatencyMs,
+        confidence: readiness === LoadStrikeAutopilotReadiness.Ready ? 0.9 : 0.5
+    });
+}
+function buildReviewResult(options, warning) {
+    return buildResult({
+        readiness: LoadStrikeAutopilotReadiness.RequiresReview,
+        options,
+        endpoints: [],
+        trackingSuggestions: [],
+        thresholdSuggestions: seedThresholds(undefined),
+        redactions: [],
+        warnings: [warning],
+        readinessFailures: [readinessFailure(LoadStrikeAutopilotReadiness.RequiresReview, warning, "ManualReview")],
+        confidence: 0.1
+    });
+}
+function buildResult(values) {
+    const plan = {
+        Version: "trace-to-test-autopilot/v1",
+        Scenario: {
+            Name: values.options.ScenarioName?.trim() || "autopilot-starter",
+            WithoutWarmUp: true,
+            LoadSimulationSuggestions: [{ Kind: "IterationsForConstant", Copies: 1, Iterations: 1 }]
+        },
+        Endpoints: values.endpoints,
+        TrackingSelectorSuggestions: values.trackingSuggestions,
+        ThresholdSuggestions: values.thresholdSuggestions,
+        Redactions: values.redactions,
+        Warnings: values.warnings,
+        Confidence: values.confidence
+    };
+    return new LoadStrikeAutopilotResult({
+        readiness: values.readiness,
+        plan,
+        endpoints: values.endpoints,
+        redactions: values.redactions,
+        warnings: values.warnings,
+        readinessFailures: values.readinessFailures,
+        httpRequest: values.httpRequest,
+        observedLatencyMs: values.observedLatencyMs
+    });
+}
+function buildPreviewReport(result) {
+    return {
+        ScenarioName: result.Plan.Scenario.Name,
+        Readiness: result.Readiness,
+        Redactions: result.Redactions,
+        Warnings: result.Warnings,
+        ReadinessFailures: result.ReadinessFailures,
+        Signals: [
+            `readiness:${result.Readiness}`,
+            `endpoints:${result.Endpoints.length}`,
+            `trackingSelectors:${result.Plan.TrackingSelectorSuggestions.length}`,
+            `thresholdSuggestions:${result.Plan.ThresholdSuggestions.length}`
+        ]
+    };
+}
+function seedThresholds(observedLatencyMs) {
+    const latencyBudget = Math.max(100, Math.ceil((observedLatencyMs ?? 100) * 1.5));
+    return [
+        { Kind: "AllFailCount", Maximum: 0 },
+        { Kind: "LatencyP95Ms", Maximum: latencyBudget },
+        { Kind: "LatencyP99Ms", Maximum: Math.ceil(latencyBudget * 1.25) }
+    ];
+}
+function compileThreshold(suggestion) {
+    if (suggestion.Kind === "AllFailCount") {
+        return LoadStrikeThreshold.scenario("AllFailCount", "<=", suggestion.Maximum);
+    }
+    return LoadStrikeThreshold.scenario(suggestion.Kind, "<=", suggestion.Maximum);
+}
+function redactHeaders(headers, redactions, bindings, markUnresolved) {
+    const next = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (isSecretKey(key)) {
+            const location = `header:${key}`;
+            next[key] = replacementForLocation(location, bindings, markUnresolved);
+            redactions.push({ Location: location, Reason: "secret-like header", Replacement: REDACTED });
+        }
+        else {
+            next[key] = value;
+        }
+    }
+    return next;
+}
+function redactUrl(url, redactions, bindings, markUnresolved) {
+    try {
+        const parsed = new URL(url);
+        let changed = false;
+        for (const key of [...parsed.searchParams.keys()]) {
+            if (isSecretKey(key)) {
+                const location = `query:${key}`;
+                parsed.searchParams.set(key, replacementForLocation(location, bindings, markUnresolved));
+                redactions.push({ Location: location, Reason: "secret-like query parameter", Replacement: REDACTED });
+                changed = true;
+            }
+        }
+        return changed ? parsed.toString() : url;
+    }
+    catch {
+        return url;
+    }
+}
+function redactBody(body, redactions, bindings, markUnresolved) {
+    if (!body?.trim()) {
+        return body;
+    }
+    try {
+        const value = JSON.parse(body);
+        const changed = redactJsonValue(value, "$", redactions, bindings, markUnresolved);
+        return changed ? JSON.stringify(value) : body;
+    }
+    catch {
+        return body;
+    }
+}
+function redactJsonValue(value, path, redactions, bindings, markUnresolved) {
+    let changed = false;
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i += 1) {
+            changed = redactJsonValue(value[i], `${path}[${i}]`, redactions, bindings, markUnresolved) || changed;
+        }
+    }
+    else if (value && typeof value === "object") {
+        const record = value;
+        for (const key of Object.keys(record)) {
+            if (isSecretKey(key)) {
+                const location = `body:${path}.${key}`;
+                record[key] = replacementForLocation(location, bindings, markUnresolved);
+                redactions.push({ Location: location, Reason: "secret-like body key", Replacement: REDACTED });
+                changed = true;
+            }
+            else {
+                changed = redactJsonValue(record[key], `${path}.${key}`, redactions, bindings, markUnresolved) || changed;
+            }
+        }
+    }
+    return changed;
+}
+function secretBindingMap(bindings) {
+    const result = new Map();
+    for (const binding of bindings) {
+        const location = normalizeBindingLocation(binding.Location);
+        const env = binding.ValueFromEnv?.trim();
+        if (location && env) {
+            result.set(location, env);
+        }
+    }
+    return result;
+}
+function replacementForLocation(location, bindings, markUnresolved) {
+    const env = bindings.get(normalizeBindingLocation(location));
+    if (env) {
+        return `${ENV_MARKER_PREFIX}${env}${ENV_MARKER_SUFFIX}`;
+    }
+    markUnresolved(location);
+    return REDACTED;
+}
+function readinessFailure(Readiness, Reason, RequiredInput, Locations = []) {
+    return {
+        Readiness,
+        Reason,
+        RequiredInput,
+        Locations: [...new Set(Locations.map((location) => location.trim()).filter(Boolean))]
+    };
+}
+function normalizeBindingLocation(location) {
+    return (location ?? "").trim().toLowerCase();
+}
+function parseEnvMarker(value) {
+    const trimmed = value.trim();
+    return trimmed.startsWith(ENV_MARKER_PREFIX) && trimmed.endsWith(ENV_MARKER_SUFFIX)
+        ? trimmed.slice(ENV_MARKER_PREFIX.length, -ENV_MARKER_SUFFIX.length).trim() || undefined
+        : undefined;
+}
+function resolveSecretMarker(value) {
+    const env = parseEnvMarker(value);
+    if (!env) {
+        return value;
+    }
+    const secret = process.env[env];
+    if (secret === undefined) {
+        throw new Error(`Autopilot secret environment variable '${env}' is not set.`);
+    }
+    return secret;
+}
+function resolveHttpRequestSecrets(request) {
+    const headers = {};
+    for (const [key, value] of Object.entries(request.headers)) {
+        headers[key] = resolveSecretMarker(value);
+    }
+    return {
+        ...request,
+        url: resolveUrlSecretMarkers(request.url),
+        headers,
+        body: resolveBodySecretMarkers(request.body)
+    };
+}
+function resolveUrlSecretMarkers(rawUrl) {
+    try {
+        const parsed = new URL(rawUrl);
+        let changed = false;
+        for (const [key, value] of [...parsed.searchParams.entries()]) {
+            const resolved = resolveSecretMarker(value);
+            if (resolved !== value) {
+                parsed.searchParams.set(key, resolved);
+                changed = true;
+            }
+        }
+        return changed ? parsed.toString() : rawUrl;
+    }
+    catch {
+        return resolveSecretMarker(rawUrl);
+    }
+}
+function resolveBodySecretMarkers(body) {
+    if (!body?.trim()) {
+        return body;
+    }
+    try {
+        const value = JSON.parse(body);
+        const changed = resolveJsonSecretMarkers(value);
+        return changed ? JSON.stringify(value) : body;
+    }
+    catch {
+        return resolveSecretMarker(body);
+    }
+}
+function resolveJsonSecretMarkers(value) {
+    let changed = false;
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            if (typeof value[index] === "string") {
+                const resolved = resolveSecretMarker(value[index]);
+                if (resolved !== value[index]) {
+                    value[index] = resolved;
+                    changed = true;
+                }
+            }
+            else {
+                changed = resolveJsonSecretMarkers(value[index]) || changed;
+            }
+        }
+    }
+    else if (value && typeof value === "object") {
+        const record = value;
+        for (const key of Object.keys(record)) {
+            if (typeof record[key] === "string") {
+                const resolved = resolveSecretMarker(record[key]);
+                if (resolved !== record[key]) {
+                    record[key] = resolved;
+                    changed = true;
+                }
+            }
+            else {
+                changed = resolveJsonSecretMarkers(record[key]) || changed;
+            }
+        }
+    }
+    return changed;
+}
+function applyEndpointBindings(endpoints, bindings) {
+    const byName = new Map();
+    for (const binding of bindings) {
+        const name = binding.Name?.trim().toLowerCase();
+        if (name) {
+            byName.set(name, binding);
+        }
+    }
+    const missing = [];
+    const next = endpoints.map((endpoint) => {
+        const binding = byName.get(endpoint.Name.trim().toLowerCase());
+        if (!binding) {
+            missing.push(endpoint.Name);
+            return endpoint;
+        }
+        return {
+            ...endpoint,
+            Kind: binding.Kind?.trim() || endpoint.Kind,
+            Method: binding.Method?.trim() || endpoint.Method,
+            Url: binding.Url?.trim() || endpoint.Url
+        };
+    });
+    return { endpoints: next, missing };
+}
+function endpointBindingUrl(bindings, name) {
+    return bindings.find((binding) => binding.Name?.trim().toLowerCase() === name.toLowerCase())?.Url?.trim() || undefined;
+}
+function resolveReplayUrl(url, options) {
+    try {
+        const parsed = new URL(url);
+        const endpointTarget = endpointBindingUrl(options.EndpointBindings ?? [], "source-http");
+        if (endpointTarget) {
+            return { url: endpointTarget, ready: true };
+        }
+        if (options.BaseUrlRewrite) {
+            const base = new URL(options.BaseUrlRewrite);
+            return { url: new URL(`${parsed.pathname}${parsed.search}`, base).toString(), ready: true };
+        }
+        const allowed = new Set((options.AllowedReplayHosts ?? []).map((host) => host.toLowerCase()));
+        if (isLoopbackHost(parsed.hostname) || allowed.has(parsed.hostname.toLowerCase())) {
+            return { url, ready: true };
+        }
+        return {
+            url,
+            ready: false,
+            warning: `Captured host '${parsed.hostname}' requires AllowedReplayHosts or BaseUrlRewrite before replay.`
+        };
+    }
+    catch {
+        return { url, ready: false, warning: "Captured URL is not absolute and requires target binding." };
+    }
+}
+function inferTrackingSelector(headers, body) {
+    for (const key of ["x-correlation-id", "correlation-id", "traceparent"]) {
+        const match = headerValue(headers, key);
+        if (match) {
+            return `header:${key}`;
+        }
+    }
+    if (!body) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(body);
+        return parsed && typeof parsed === "object" && "orderId" in parsed ? "json:$.orderId" : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function findSharedHeaderSelector(source, destination) {
+    for (const [key, value] of Object.entries(source)) {
+        const destinationValue = headerValue(destination, key);
+        if (destinationValue === value) {
+            return `header:${key}`;
+        }
+    }
+    return undefined;
+}
+function readHeaders(sample) {
+    return sample.headers ?? sample.Headers ?? {};
+}
+function readOtelAttributes(span) {
+    const result = {};
+    for (const attribute of asArray(span.attributes)) {
+        const item = asRecord(attribute);
+        const key = asString(item.key);
+        if (!key) {
+            continue;
+        }
+        const value = asRecord(item.value);
+        result[key] = asString(value.stringValue) ?? asString(value.intValue) ?? JSON.stringify(value);
+    }
+    return result;
+}
+function findFirstSpan(root) {
+    for (const resourceSpan of asArray(root.resourceSpans)) {
+        for (const scopeSpan of asArray(asRecord(resourceSpan).scopeSpans)) {
+            const spans = asArray(asRecord(scopeSpan).spans);
+            if (spans.length > 0) {
+                return asRecord(spans[0]);
+            }
+        }
+    }
+    return undefined;
+}
+function readSpanDurationMs(span) {
+    const start = BigInt(asString(span.startTimeUnixNano) ?? "0");
+    const end = BigInt(asString(span.endTimeUnixNano) ?? "0");
+    return end >= start ? Number(end - start) / 1000000 : undefined;
+}
+function headerValue(headers, name) {
+    const match = Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase());
+    return match?.[1];
+}
+function isSecretKey(key) {
+    const lower = key.toLowerCase();
+    return SECRET_KEYS.has(lower) || SECRET_KEYS.has(lower.replace(/-/g, "_"));
+}
+function isLoopbackHost(host) {
+    return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+function equalsKind(actual, expected) {
+    return actual.toLowerCase() === expected.toLowerCase();
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return String(value);
+    }
+    return undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}