@foam-ai/node 0.1.0-alpha.5 → 0.1.0-alpha.6

package/dist/network-capture/redact.js

@@ -1,32 +1,93 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSensitiveBodyKey = isSensitiveBodyKey;
+exports.isNdjsonMediaType = isNdjsonMediaType;
+exports.isJsonSequenceMediaType = isJsonSequenceMediaType;
+exports.isTextualBodyMediaType = isTextualBodyMediaType;
 exports.redactBodyText = redactBodyText;
 const constants_js_1 = require("../constants.js");
-const EXACT_KEYS = new Set(constants_js_1.SENSITIVE_BODY_KEYS_EXACT);
-function normalizeKey(key) {
-    return key.toLowerCase().replace(/[-_.\s]/g, "");
+const redaction_js_1 = require("../redaction.js");
+const NDJSON_MEDIA_TYPES = new Set([
+    "application/json-stream",
+    "application/jsonl",
+    "application/jsonlines",
+    "application/ndjson",
+    "application/stream+json",
+    "application/x-json-stream",
+    "application/x-jsonlines",
+    "application/x-ldjson",
+    "application/x-ndjson",
+]);
+const JSON_SEQUENCE_MEDIA_TYPES = new Set([
+    "application/json-seq",
+    "application/x-json-seq",
+]);
+const XML_MEDIA_TYPES = new Set([
+    "application/xml",
+    "text/html",
+    "text/xml",
+]);
+const YAML_MEDIA_TYPES = new Set([
+    "application/x-yaml",
+    "application/yaml",
+    "text/x-yaml",
+    "text/yaml",
+]);
+function rawHeader(value) {
+    const first = Array.isArray(value) ? value[0] : value;
+    return typeof first === "string" ? first : "";
+}
+function parseContentType(value) {
+    const raw = rawHeader(value);
+    const media = (raw.split(";", 1)[0] ?? "").trim().toLowerCase();
+    const params = new Map();
+    const pattern = /;\s*([^=;\s]+)\s*=\s*(?:"([^"]*)"|([^;]*))/g;
+    let match;
+    while ((match = pattern.exec(raw)) !== null) {
+        params.set(match[1].toLowerCase(), (match[2] ?? match[3] ?? "").trim());
+    }
+    return { media, params };
 }
 function isSensitiveBodyKey(key) {
-    const normalized = normalizeKey(key);
-    return (EXACT_KEYS.has(normalized) ||
-        constants_js_1.SENSITIVE_BODY_KEY_PATTERNS.some((pattern) => normalized.includes(pattern)));
+    return (0, redaction_js_1.keyMatch)(key) !== undefined;
+}
+function isNdjsonMediaType(media) {
+    return (NDJSON_MEDIA_TYPES.has(media) ||
+        media.endsWith("+ndjson") ||
+        media.endsWith("/ndjson"));
+}
+function isJsonSequenceMediaType(media) {
+    return JSON_SEQUENCE_MEDIA_TYPES.has(media) || media.endsWith("+json-seq");
 }
-function mediaType(contentType) {
-    const raw = Array.isArray(contentType) ? contentType[0] : contentType;
-    if (typeof raw !== "string")
-        return "";
-    return (raw.split(";")[0] ?? "").trim().toLowerCase();
+function isTextualBodyMediaType(media) {
+    return (media.startsWith("text/") ||
+        media.startsWith("multipart/") ||
+        media.endsWith("/json") ||
+        media.endsWith("+json") ||
+        media.endsWith("/xml") ||
+        media.endsWith("+xml") ||
+        media.endsWith("/yaml") ||
+        media.endsWith("+yaml") ||
+        isNdjsonMediaType(media) ||
+        isJsonSequenceMediaType(media) ||
+        media === "application/x-www-form-urlencoded");
 }
 function redactNode(node, state) {
+    if (typeof node === "string") {
+        const value = (0, redaction_js_1.redactString)(node);
+        if (value !== node)
+            state.changed = true;
+        return value;
+    }
     if (Array.isArray(node)) {
         return node.map((item) => redactNode(item, state));
     }
     if (node !== null && typeof node === "object") {
         const result = {};
         for (const [key, value] of Object.entries(node)) {
-            if (isSensitiveBodyKey(key) && value !== null && value !== undefined) {
-                result[key] = constants_js_1.REDACTED_VALUE;
+            const match = (0, redaction_js_1.keyMatch)(key);
+            if (match && value !== null && value !== undefined) {
+                result[key] = (0, redaction_js_1.maskForMatch)(match, value);
                 state.changed = true;
             }
             else {
@@ -37,17 +98,18 @@ function redactNode(node, state) {
     }
     return node;
 }
-// pcga11: Captures a "key": value pair with a string (possibly unterminated
-// at a truncation point), number, or literal value. Used only when the body
-// does not parse as JSON, e.g. because the 1 MiB cap cut it mid-document.
 const JSON_PAIR_PATTERN = /"((?:[^"\\]|\\.)*)"(\s*:\s*)("(?:[^"\\]|\\.)*"?|-?\d[\d.eE+-]*|true|false|null)/g;
+function fallbackMask(kind) {
+    return kind === "secret" ? constants_js_1.FULL_MASK : constants_js_1.REDACTED_VALUE;
+}
 function redactJsonFallback(text) {
     let changed = false;
     const redacted = text.replace(JSON_PAIR_PATTERN, (match, key, separator) => {
-        if (!isSensitiveBodyKey(key))
+        const kind = (0, redaction_js_1.keyMatch)(key);
+        if (!kind)
             return match;
         changed = true;
-        return `"${key}"${separator}"${constants_js_1.REDACTED_VALUE}"`;
+        return `"${key}"${separator}"${fallbackMask(kind)}"`;
     });
     return changed ? { text: redacted, changed } : { text, changed: false };
 }
@@ -61,27 +123,279 @@ function redactJson(text) {
     }
     const state = { changed: false };
     const redacted = redactNode(parsed, state);
-    if (!state.changed)
-        return { text, changed: false };
-    return { text: JSON.stringify(redacted), changed: true };
+    return state.changed
+        ? { text: JSON.stringify(redacted), changed: true }
+        : { text, changed: false };
+}
+function redactByLine(text, redactLine) {
+    let changed = false;
+    const lines = text.split("\n").map((raw) => {
+        const hasCr = raw.endsWith("\r");
+        const line = hasCr ? raw.slice(0, -1) : raw;
+        if (!line)
+            return raw;
+        const result = redactLine(line);
+        if (!result.changed)
+            return raw;
+        changed = true;
+        return hasCr ? `${result.text}\r` : result.text;
+    });
+    return changed
+        ? { text: lines.join("\n"), changed: true }
+        : { text, changed: false };
+}
+function redactNdjson(text) {
+    return redactByLine(text, redactJson);
+}
+function redactJsonSequence(text) {
+    if (!text.includes("\u001e"))
+        return redactJson(text);
+    let changed = false;
+    const segments = text.split("\u001e");
+    const redacted = segments.map((segment, index) => {
+        if (index === 0 || !segment)
+            return segment;
+        const ending = segment.match(/(?:\r\n|\n|\r)$/)?.[0] ?? "";
+        const document = ending ? segment.slice(0, -ending.length) : segment;
+        const result = redactJson(document);
+        if (!result.changed)
+            return segment;
+        changed = true;
+        return `${result.text}${ending}`;
+    });
+    return changed
+        ? { text: redacted.join("\u001e"), changed: true }
+        : { text, changed: false };
+}
+function redactSseBlock(block) {
+    const lineEnding = block.match(/\r\n|\n|\r/)?.[0] ?? "\n";
+    const lines = block.split(/\r\n|\n|\r/);
+    const data = [];
+    lines.forEach((line, index) => {
+        const match = /^(data: ?)(.*)$/.exec(line);
+        if (match) {
+            data.push({ index, prefix: match[1], value: match[2] });
+        }
+    });
+    if (data.length === 0)
+        return { text: block, changed: false };
+    const payload = data.map((entry) => entry.value).join("\n");
+    const json = redactJson(payload);
+    const plain = json.changed ? json : redactPlainText(payload);
+    if (!plain.changed)
+        return { text: block, changed: false };
+    lines[data[0].index] = `${data[0].prefix}${plain.text}`;
+    for (let index = data.length - 1; index >= 1; index -= 1) {
+        lines.splice(data[index].index, 1);
+    }
+    return { text: lines.join(lineEnding), changed: true };
+}
+function redactSse(text) {
+    const separator = /(\r\n\r\n|\n\n|\r\r)/;
+    const parts = text.split(separator);
+    let changed = false;
+    for (let index = 0; index < parts.length; index += 2) {
+        const result = redactSseBlock(parts[index]);
+        if (result.changed) {
+            parts[index] = result.text;
+            changed = true;
+        }
+    }
+    return changed
+        ? { text: parts.join(""), changed: true }
+        : { text, changed: false };
 }
 function redactForm(text) {
     const params = new URLSearchParams(text);
     let changed = false;
     for (const key of new Set(params.keys())) {
-        if (!isSensitiveBodyKey(key))
+        if (!(0, redaction_js_1.keyMatch)(key) && !(0, redaction_js_1.isSensitiveQueryKey)(key))
             continue;
         params.set(key, constants_js_1.REDACTED_VALUE);
         changed = true;
     }
-    return changed ? { text: params.toString(), changed } : { text, changed: false };
+    return changed
+        ? { text: params.toString(), changed: true }
+        : { text, changed: false };
+}
+function localName(name) {
+    const separator = name.lastIndexOf(":");
+    return separator < 0 ? name : name.slice(separator + 1);
+}
+function escapePattern(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function redactXmlElements(text) {
+    let changed = false;
+    let cursor = 0;
+    let output = "";
+    const opening = /<([A-Za-z_][\w:.-]*)(?:\s[^>]*)?>/g;
+    let match;
+    while ((match = opening.exec(text)) !== null) {
+        if (match[0].endsWith("/>"))
+            continue;
+        const kind = (0, redaction_js_1.keyMatch)(localName(match[1]));
+        if (!kind)
+            continue;
+        const closing = new RegExp(`</${escapePattern(match[1])}\\s*>`, "g");
+        closing.lastIndex = opening.lastIndex;
+        const close = closing.exec(text);
+        output += text.slice(cursor, opening.lastIndex);
+        if (!close) {
+            output += fallbackMask(kind);
+            cursor = text.length;
+            changed = true;
+            break;
+        }
+        const value = text.slice(opening.lastIndex, close.index);
+        output += `${value.includes("<") ? fallbackMask(kind) : (0, redaction_js_1.maskForMatch)(kind, value)}${close[0]}`;
+        cursor = closing.lastIndex;
+        opening.lastIndex = cursor;
+        changed = true;
+    }
+    if (!changed)
+        return { text, changed: false };
+    return { text: output + text.slice(cursor), changed: true };
+}
+function redactXml(text) {
+    const elements = redactXmlElements(text);
+    let changed = elements.changed;
+    let output = elements.text;
+    output = output.replace(/(\s)([A-Za-z_:][\w:.-]*)(\s*=\s*)(["'])(.*?)\4/g, (match, spacing, name, separator, quote, value) => {
+        const kind = (0, redaction_js_1.keyMatch)(localName(name));
+        if (!kind)
+            return match;
+        changed = true;
+        return `${spacing}${name}${separator}${quote}${(0, redaction_js_1.maskForMatch)(kind, value)}${quote}`;
+    });
+    output = output.replace(/<input\b[^>]*>/gi, (tag) => {
+        const name = /\bname\s*=\s*(["'])(.*?)\1/i.exec(tag)?.[2];
+        if (!name || (!(0, redaction_js_1.keyMatch)(name) && !(0, redaction_js_1.isSensitiveQueryKey)(name)))
+            return tag;
+        const replaced = tag.replace(/(\bvalue\s*=\s*)(["'])(.*?)\2/i, `$1$2${constants_js_1.REDACTED_VALUE}$2`);
+        if (replaced === tag)
+            return tag;
+        changed = true;
+        return replaced;
+    });
+    return changed ? { text: output, changed: true } : { text, changed: false };
+}
+const YAML_PAIR = /^(\s*(?:-\s*)?)(["']?)([A-Za-z_][\w.-]*)\2(\s*:\s*)(.*)$/;
+function redactYaml(text) {
+    let blockSecret = false;
+    const result = redactByLine(text, (line) => {
+        const match = YAML_PAIR.exec(line);
+        if (!match)
+            return { text: line, changed: false };
+        const kind = (0, redaction_js_1.keyMatch)(match[3]);
+        if (!kind)
+            return { text: line, changed: false };
+        if (/^[>|]/.test(match[5].trim()))
+            blockSecret = true;
+        return {
+            text: `${match[1]}${match[2]}${match[3]}${match[2]}${match[4]}${(0, redaction_js_1.maskForMatch)(kind, match[5].trim().replace(/^(["'])(.*)\1$/, "$2"))}`,
+            changed: true,
+        };
+    });
+    return blockSecret ? { text: constants_js_1.REDACTED_VALUE, changed: true } : result;
+}
+function redactPlainText(text) {
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        const json = redactJson(text);
+        if (json.changed)
+            return json;
+    }
+    const yaml = redactYaml(text);
+    if (yaml.changed)
+        return yaml;
+    const redacted = (0, redaction_js_1.redactString)(text);
+    return redacted === text
+        ? { text, changed: false }
+        : { text: redacted, changed: true };
+}
+function contentDispositionName(headers) {
+    const line = headers
+        .split(/\r\n|\n|\r/)
+        .find((header) => /^content-disposition\s*:/i.test(header));
+    return line ? /\bname\s*=\s*(?:"([^"]*)"|([^;\s]*))/i.exec(line)?.slice(1).find(Boolean) : undefined;
+}
+function partContentType(headers) {
+    return headers
+        .split(/\r\n|\n|\r/)
+        .find((header) => /^content-type\s*:/i.test(header))
+        ?.replace(/^[^:]+:\s*/, "");
+}
+function redactMultipart(text, boundary) {
+    if (!boundary || boundary.length > 70)
+        return { text, changed: false };
+    const marker = `--${boundary}`;
+    if (!text.includes(marker))
+        return { text, changed: false };
+    let changed = false;
+    const parts = text.split(marker);
+    for (let index = 1; index < parts.length; index += 1) {
+        const part = parts[index];
+        if (part.startsWith("--"))
+            continue;
+        const leading = part.match(/^(?:\r\n|\n|\r)/)?.[0] ?? "";
+        const content = leading ? part.slice(leading.length) : part;
+        const separator = /\r\n\r\n|\n\n|\r\r/.exec(content);
+        if (!separator?.index)
+            continue;
+        const headers = content.slice(0, separator.index);
+        const bodyWithEnding = content.slice(separator.index + separator[0].length);
+        const ending = bodyWithEnding.match(/(?:\r\n|\n|\r)$/)?.[0] ?? "";
+        const body = ending
+            ? bodyWithEnding.slice(0, -ending.length)
+            : bodyWithEnding;
+        const name = contentDispositionName(headers);
+        let result;
+        if (name && ((0, redaction_js_1.keyMatch)(name) || (0, redaction_js_1.isSensitiveQueryKey)(name))) {
+            result = { text: constants_js_1.REDACTED_VALUE, changed: true };
+        }
+        else if (/\bfilename\s*=/i.test(headers)) {
+            result = { text: body, changed: false };
+        }
+        else {
+            result = redactBodyText(body, partContentType(headers) ?? "text/plain");
+        }
+        if (!result.changed)
+            continue;
+        parts[index] = `${leading}${headers}${separator[0]}${result.text}${ending}`;
+        changed = true;
+    }
+    return changed
+        ? { text: parts.join(marker), changed: true }
+        : { text, changed: false };
 }
 function redactBodyText(text, contentType) {
-    const media = mediaType(contentType);
+    const { media, params } = parseContentType(contentType);
     if (media === "application/x-www-form-urlencoded")
         return redactForm(text);
-    if (media.endsWith("/json") || media.endsWith("+json")) {
+    if (media === "text/event-stream")
+        return redactSse(text);
+    if (isJsonSequenceMediaType(media))
+        return redactJsonSequence(text);
+    if (isNdjsonMediaType(media))
+        return redactNdjson(text);
+    if (media.endsWith("/json") || media.endsWith("+json"))
         return redactJson(text);
+    if (media.startsWith("multipart/")) {
+        return redactMultipart(text, params.get("boundary") ?? "");
+    }
+    if (XML_MEDIA_TYPES.has(media) ||
+        media.endsWith("/xml") ||
+        media.endsWith("+xml")) {
+        return redactXml(text);
+    }
+    if (YAML_MEDIA_TYPES.has(media) ||
+        media.endsWith("/yaml") ||
+        media.endsWith("+yaml")) {
+        return redactYaml(text);
+    }
+    if (media.startsWith("text/") || params.has("charset")) {
+        return redactPlainText(text);
     }
     return { text, changed: false };
 }

package/dist/propagation.d.ts

@@ -1,5 +1,5 @@
 import { type Context } from "@opentelemetry/api";
 export declare function injectTraceContext(carrier: Record<string, string>): void;
 export declare function extractTraceContext(carrier: Record<string, string>): Context;
-export declare const setBaggage: (key: string, value: string) => void;
+export declare function setBaggage<T>(key: string, value: string, callback: () => T): T | undefined;
 export declare function getBaggage(key: string): string | undefined;

package/dist/propagation.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setBaggage = void 0;
 exports.injectTraceContext = injectTraceContext;
 exports.extractTraceContext = extractTraceContext;
+exports.setBaggage = setBaggage;
 exports.getBaggage = getBaggage;
 const node_async_hooks_1 = require("node:async_hooks");
 const api_1 = require("@opentelemetry/api");
@@ -34,11 +34,13 @@ function injectTraceContext(carrier) {
 function extractTraceContext(carrier) {
     return (0, utils_js_1.safely)(() => propagator.extract(api_1.context.active(), carrier, api_1.defaultTextMapGetter), api_1.context.active());
 }
-exports.setBaggage = (0, utils_js_1.whenInitialized)(state_js_1.Signals.baggage, (key, value) => {
+function setBaggage(key, value, callback) {
+    if ((0, state_js_1.getSignal)(state_js_1.Signals.baggage) === state_js_1.SignalSources.none)
+        return undefined;
     const next = new Map(baggageStorage.getStore() ?? []);
     next.set(key, value);
-    baggageStorage.enterWith(next);
-});
+    return baggageStorage.run(next, callback);
+}
 function getBaggage(key) {
     return (0, utils_js_1.safely)(() => baggageStorage.getStore()?.get(key) ??
         api_1.propagation.getBaggage(api_1.context.active())?.getEntry(key)?.value, undefined);

package/dist/redaction-keys.d.ts

@@ -0,0 +1,3 @@
+export declare const SENSITIVE_KEYS: readonly ["admin_password", "basic_auth_password", "confirm_password", "connection_password", "current_password", "database_password", "db_pass", "db_password", "ftp_password", "http_password", "keystore_password", "master_password", "mail_password", "mysql_pwd", "new_password", "old_password", "pass", "passcode", "passphrase", "passwd", "password", "password_confirmation", "postgres_password", "pwd", "redis_password", "root_password", "smtp_password", "user_password", "access_token_secret", "activation_token", "access_token", "api_token", "assertion", "auth", "auth_token", "authentication_token", "authorization", "authorization_code", "bearer", "bearer_token", "bot_token", "ci_job_token", "client_assertion", "client_secret", "credential", "credentials", "deploy_token", "email_verification_token", "id_token", "identity_token", "invite_token", "jwt", "jwt_token", "magic_link_token", "oauth_token", "oauth2_token", "oauth_token_secret", "password_reset_token", "personal_access_token", "registration_token", "request_token", "refresh_token", "reset_token", "saml_assertion", "saml_response", "secret_token", "security_token", "service_token", "sso_token", "token", "unsubscribe_token", "verification_token", "access_key", "access_key_id", "api_key", "api_secret", "amqp_url", "apikey", "app_key", "app_secret", "application_key", "application_secret", "aws_access_key_id", "aws_secret_access_key", "consumer_key", "consumer_secret", "broker_url", "connection_string", "connection_uri", "credential_blob", "decryption_key", "database_url", "database_connection_string", "db_url", "dsn", "encryption_key", "gcp_service_account_key", "google_application_credentials", "key", "key_password", "key_store_password", "keystore", "license_key", "mnemonic", "mongodb_uri", "kube_config", "kubeconfig", "pem", "private_key", "privatekey", "proxy_authorization", "redis_url", "redis_uri", "rabbitmq_url", "secret", "secret_access_key", "secret_key", "seed_phrase", "service_account_json", "service_account_key", "shared_secret", "signature", "signing_key", "signing_secret", "ssh_private_key", "smtp_url", "tls_private_key", "wallet_private_key", "wallet_seed", "webhook_secret", "www_authenticate", "_csrf", "_csrf_token", "_session", "_xsrf", "aiohttp_session", "anti_forgery_token", "backup_code", "backup_codes", "connect.sid", "cookie", "csrf", "csrf_token", "csrftoken", "django_session", "hotp", "laravel_session", "mfa", "mfa_code", "otp", "phpsessid", "pin", "recovery_code", "recovery_codes", "remember_token", "session", "session_id", "session_key", "session_token", "sessionid", "set_cookie", "setcookie", "sid", "symfony", "totp", "user_session", "x_csrf_token", "x_csrftoken", "x_xsrf_token", "xsrf", "xsrf_token", "account_number", "bank_account", "card", "card_number", "credit_card", "credit_card_number", "cvc", "cvv", "date_of_birth", "dob", "driver_license", "drivers_license", "iban", "ip_address", "national_id", "passport_number", "remote_addr", "routing_number", "sort_code", "ssn", "tax_id", "x_forwarded_for", "x_real_ip", "algolia_admin_api_key", "anthropic_api_key", "artifactory_api_key", "airtable_api_key", "azure_api_key", "buildkite_agent_token", "circle_token", "cohere_api_key", "cloudflare_api_token", "consul_http_token", "datadog_api_key", "datadog_app_key", "discord_bot_token", "docker_password", "docker_config_json", "digitalocean_token", "firebase_service_account", "gemini_api_key", "github_token", "gitlab_token", "google_api_key", "groq_api_key", "honeycomb_api_key", "huggingface_token", "heroku_api_key", "jfrog_access_token", "linear_api_key", "mapbox_access_token", "new_relic_license_key", "nomad_token", "notion_token", "npm_token", "openai_api_key", "pagerduty_routing_key", "pypi_token", "sentry_auth_token", "sentry_dsn", "sendgrid_api_key", "shopify_access_token", "shopify_api_secret", "slack_app_token", "slack_bot_token", "slack_signing_secret", "stripe_secret_key", "stripe_webhook_secret", "supabase_service_role_key", "telegram_bot_token", "terraform_cloud_token", "twilio_auth_token", "vault_token", "vercel_oidc_token", "x_api_key", "x_auth_token"];
+export declare const SENSITIVE_HTTP_HEADERS: readonly ["authentication_info", "authorization", "cf_access_authenticated_user_email", "cf_access_jwt_assertion", "cookie", "grpcgateway_authorization", "impersonate_group", "impersonate_user", "jenkins_crumb", "job_token", "ocp_apim_subscription_key", "private_token", "proxy_authenticate", "proxy_authentication_info", "proxy_authorization", "set_cookie", "stripe_signature", "www_authenticate", "x_access_token", "x_algolia_api_key", "x_amz_credential", "x_amz_security_token", "x_amz_signature", "x_amzn_oidc_accesstoken", "x_amzn_oidc_data", "x_amzn_oidc_identity", "x_api_key", "x_asana_request_token", "x_aws_ec2_metadata_token", "x_auth_request_access_token", "x_auth_request_email", "x_auth_request_groups", "x_auth_request_preferred_username", "x_auth_request_user", "x_auth_token", "x_box_signature_primary", "x_box_signature_secondary", "x_cf_access_jwt_assertion", "x_csrf_token", "x_circle_token", "x_consul_token", "x_credential_identifier", "x_datadog_api_key", "x_discord_signature_ed25519", "x_docusign_signature_1", "x_dropbox_signature", "x_elastic_client_authentication", "x_firebase_appcheck", "x_forwarded_access_token", "x_forwarded_email", "x_forwarded_for", "x_forwarded_user", "x_functions_key", "x_github_token", "x_gitlab_token", "x_goog_api_key", "x_goog_firebase_installations_auth", "x_goog_iap_jwt_assertion", "x_hub_signature", "x_hub_signature_256", "x_honeycomb_api_key", "x_honeycomb_team", "x_intercom_hmac", "x_jwt_assertion", "x_linear_signature", "x_mailgun_signature", "x_master_key", "x_meili_api_key", "x_ms_client_principal", "x_ms_token_aad_access_token", "x_ms_token_aad_id_token", "x_ms_token_aad_refresh_token", "x_nf_client_connection_ip", "x_nomad_token", "x_npm_token", "x_original_authorization", "x_real_ip", "x_remote_email", "x_remote_groups", "x_remote_user", "x_pagerduty_signature", "x_parse_rest_api_key", "x_sendgrid_event_webhook_signature", "x_session_token", "x_shopify_hmac_sha256", "x_signature", "x_signature_ed25519", "x_slack_signature", "x_sonarqube_passcode", "x_squarespace_hmacsha256_signature", "x_twilio_signature", "x_typesense_api_key", "x_userinfo", "x_vault_token", "x_vercel_oidc_token", "x_webhook_signature", "x_webhook_secret", "x_wix_webhook_signature", "x_xsrf_token", "x_zendesk_webhook_signature"];
+export declare const SENSITIVE_QUERY_KEYS: readonly ["access_token", "api_key", "api_secret", "api_token", "apikey", "assertion", "auth", "auth_token", "authorization", "authorization_code", "bearer_token", "client_assertion", "client_secret", "code", "code_verifier", "credential", "hmac", "id_token", "invite_token", "jwt", "key", "magic_link_token", "oauth_token_secret", "otp", "password_reset_token", "password", "policy", "pin", "refresh_token", "reset_token", "saml_response", "secret", "secret_key", "session", "session_id", "session_token", "sig", "signature", "token", "token_secret", "unsubscribe_token", "verification_token", "x_amz_credential", "x_amz_security_token", "x_amz_signature", "x_goog_credential", "x_goog_signature"];