@ansight/capacitor 1.3.0-preview.1 → 1.3.0-preview.11

package/dist/plugin.cjs.js

@@ -4,6 +4,18 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var core = require('@capacitor/core');
 
+function createTypeRegistry() {
+    return { idsByTypeName: new Map(), types: [] };
+}
+function registerType(registry, typeName) {
+    const existingTypeId = registry.idsByTypeName.get(typeName);
+    if (existingTypeId !== undefined)
+        return existingTypeId;
+    const typeId = registry.types.length;
+    registry.types.push(typeName);
+    registry.idsByTypeName.set(typeName, typeId);
+    return typeId;
+}
 const nodeIds = new WeakMap();
 let nextNodeId = 1;
 function nodeId(element) {
@@ -50,6 +62,55 @@ function automationId(element) {
         element.id ??
         undefined)?.trim() || undefined);
 }
+function semanticRole(element) {
+    const declared = element.getAttribute("role")?.trim().toLowerCase();
+    if (declared)
+        return declared;
+    if (element instanceof HTMLButtonElement)
+        return "button";
+    if (element instanceof HTMLInputElement) {
+        if (element.type === "checkbox")
+            return "checkbox";
+        if (element.type === "radio")
+            return "radio";
+        if (element.type === "range")
+            return "slider";
+        if (["button", "submit", "reset"].includes(element.type))
+            return "button";
+        return "textbox";
+    }
+    if (element instanceof HTMLTextAreaElement)
+        return "textbox";
+    if (element instanceof HTMLSelectElement)
+        return "combobox";
+    if (element.tagName === "A")
+        return "link";
+    if (/^H[1-6]$/.test(element.tagName))
+        return "heading";
+    return "view";
+}
+function supportedActions(element, allowActions) {
+    if (!allowActions)
+        return [];
+    const actions = [];
+    if (["A", "BUTTON", "SUMMARY"].includes(element.tagName) ||
+        element instanceof HTMLInputElement) {
+        actions.push("tap");
+    }
+    if (element instanceof HTMLInputElement ||
+        element instanceof HTMLTextAreaElement ||
+        element instanceof HTMLSelectElement) {
+        actions.push("typeText", "focus");
+    }
+    else if (element.tabIndex >= 0) {
+        actions.push("focus");
+    }
+    if (element.scrollHeight >
+        element.clientHeight) {
+        actions.push("scroll", "swipe");
+    }
+    return [...new Set(actions)];
+}
 function computedColorToArgbHex(value) {
     const normalized = value.trim().toLowerCase();
     if (!normalized)
@@ -115,7 +176,7 @@ function displayedValue(element) {
     const normalized = value?.replace(/\s+/g, " ").trim();
     return normalized ? normalized.slice(0, 240) : undefined;
 }
-function captureNode(element, options, depth, limits) {
+function captureNode(element, options, depth, limits, typeRegistry) {
     if (limits.count >= limits.maxNodes || depth > limits.maxDepth)
         return null;
     const style = getComputedStyle(element);
@@ -125,17 +186,23 @@ function captureNode(element, options, depth, limits) {
         return null;
     limits.count += 1;
     const children = Array.from(element.children)
-        .map((child) => captureNode(child, options, depth + 1, limits))
+        .map((child) => captureNode(child, options, depth + 1, limits, typeRegistry))
         .filter((child) => child !== null);
     const htmlElement = element;
     const disabled = element.hasAttribute("disabled") ||
         element.getAttribute("aria-disabled") === "true";
     const parsedOpacity = Number.parseFloat(style.opacity);
-    return {
+    const parsedZIndex = Number.parseFloat(style.zIndex);
+    const actions = supportedActions(element, options.allowActions);
+    const label = accessibleLabel(element, options.includeText);
+    const node = {
         id: nodeId(element),
-        type: element.tagName.toLowerCase(),
+        typeId: registerType(typeRegistry, element.tagName.toLowerCase()),
         automationId: automationId(element),
-        label: accessibleLabel(element, options.includeText),
+        label,
+        role: semanticRole(element),
+        supportedActions: actions,
+        interactable: visible && !disabled && actions.length > 0,
         visible,
         enabled: !disabled,
         focusable: htmlElement.tabIndex >= 0 ||
@@ -160,12 +227,15 @@ function captureNode(element, options, depth, limits) {
             id: element.id || undefined,
             role: element.getAttribute("role") ?? undefined,
             className: element.getAttribute("class") ?? undefined,
-            value: options.includeText ? displayedValue(element) : undefined,
             checked: element instanceof HTMLInputElement ? element.checked : undefined,
             attributes: options.includeAttributes ? attributes(element) : undefined,
         },
         children,
     };
+    if (Number.isFinite(parsedZIndex) && parsedZIndex !== 0) {
+        node.z = parsedZIndex;
+    }
+    return node;
 }
 function findElement(id) {
     return Array.from(document.querySelectorAll("*")).find((element) => nodeId(element) === id);
@@ -198,12 +268,15 @@ function installDomTools$1(registerTool, input = {}) {
                 maxNodes: options.maxNodes,
                 count: 0,
             };
-            const tree = captureNode(root, options, 0, limits);
+            const typeRegistry = createTypeRegistry();
+            const tree = captureNode(root, options, 0, limits, typeRegistry);
             return successful({
+                format: "ansight.dom.visual-tree.compact.v2",
                 platform: "web",
                 source: options.source,
                 adapter: "@ansight/capacitor",
                 capturedAtUtc: new Date().toISOString(),
+                types: typeRegistry.types,
                 truncated: limits.count >= limits.maxNodes,
                 root: tree,
             }, "DOM document captured.");
@@ -229,7 +302,17 @@ function installDomTools$1(registerTool, input = {}) {
                 };
             }
             const limits = { maxDepth: 0, maxNodes: 1, count: 0 };
-            return successful(captureNode(element, options, 0, limits), "DOM node captured.");
+            const typeRegistry = createTypeRegistry();
+            const node = captureNode(element, options, 0, limits, typeRegistry);
+            return successful({
+                format: "ansight.dom.visual-tree.compact.v2",
+                platform: "web",
+                source: options.source,
+                adapter: "@ansight/capacitor",
+                capturedAtUtc: new Date().toISOString(),
+                types: typeRegistry.types,
+                node,
+            }, "DOM node captured.");
         }),
         registerTool({
             id: "dom.query_selector",
@@ -336,6 +419,8 @@ class AnsightOptionsBuilder {
             retentionPeriodSeconds: 120,
             enableFramesPerSecond: true,
             enableBatteryLevel: false,
+            enableOpenFileHandleTracking: false,
+            enableJniReferenceCountTracking: false,
             sessionJpegCapture: {
                 intervalMilliseconds: 2000,
                 quality: 60,
@@ -378,6 +463,22 @@ class AnsightOptionsBuilder {
         this.options.enableBatteryLevel = false;
         return this;
     }
+    withOpenFileHandleTracking() {
+        this.options.enableOpenFileHandleTracking = true;
+        return this;
+    }
+    withoutOpenFileHandleTracking() {
+        this.options.enableOpenFileHandleTracking = false;
+        return this;
+    }
+    withJniReferenceCountTracking() {
+        this.options.enableJniReferenceCountTracking = true;
+        return this;
+    }
+    withoutJniReferenceCountTracking() {
+        this.options.enableJniReferenceCountTracking = false;
+        return this;
+    }
     withRetentionPeriodSeconds(value) {
         this.options.retentionPeriodSeconds = value;
         return this;
@@ -416,7 +517,7 @@ class AnsightOptionsBuilder {
         this.options.defaultMemoryChannels = current;
         return this;
     }
-    withSessionJpegCapture(optionsOrIntervalMilliseconds = {}, quality = 60, maxWidth = 480, captureGpuBackedSurfaces = true, mode = "screenshotOnly") {
+    withSessionJpegCapture(optionsOrIntervalMilliseconds = {}, quality = 60, maxWidth = 480, captureGpuBackedSurfaces = true, mode = "screenshotOnly", captureKeyboardPresence = false) {
         this.options.sessionJpegCapture =
             typeof optionsOrIntervalMilliseconds === "number"
                 ? {
@@ -425,11 +526,13 @@ class AnsightOptionsBuilder {
                     maxWidth,
                     captureGpuBackedSurfaces,
                     mode,
+                    captureKeyboardPresence,
                 }
                 : {
                     intervalMilliseconds: 2000,
                     quality: 60,
                     maxWidth: 480,
+                    captureKeyboardPresence: false,
                     mode: "screenshotOnly",
                     ...optionsOrIntervalMilliseconds,
                 };
@@ -447,6 +550,14 @@ class AnsightOptionsBuilder {
         this.options.touchCapture = false;
         return this;
     }
+    withCrashCapture(options = {}) {
+        this.options.crashCapture = { ...options, enabled: true };
+        return this;
+    }
+    withoutCrashCapture() {
+        this.options.crashCapture = false;
+        return this;
+    }
     withLifecycleCapture(options = {}) {
         this.options.lifecycleCapture = {
             ...options,
@@ -454,6 +565,50 @@ class AnsightOptionsBuilder {
         };
         return this;
     }
+    withNetworkCapture(options = {}) {
+        this.options.networkCapture = { ...options };
+        return this;
+    }
+    withNetworkRequestBodies(maximumBodyBytes) {
+        if (typeof this.options.networkCapture !== "object")
+            return this;
+        const current = this.options.networkCapture;
+        this.options.networkCapture = {
+            ...current,
+            captureRequestBody: true,
+            ...(maximumBodyBytes == null ? {} : { maximumBodyBytes }),
+        };
+        return this;
+    }
+    withoutNetworkRequestBodies() {
+        if (typeof this.options.networkCapture !== "object")
+            return this;
+        const current = this.options.networkCapture;
+        this.options.networkCapture = { ...current, captureRequestBody: false };
+        return this;
+    }
+    withNetworkResponseBodies(maximumBodyBytes) {
+        if (typeof this.options.networkCapture !== "object")
+            return this;
+        const current = this.options.networkCapture;
+        this.options.networkCapture = {
+            ...current,
+            captureResponseBody: true,
+            ...(maximumBodyBytes == null ? {} : { maximumBodyBytes }),
+        };
+        return this;
+    }
+    withoutNetworkResponseBodies() {
+        if (typeof this.options.networkCapture !== "object")
+            return this;
+        const current = this.options.networkCapture;
+        this.options.networkCapture = { ...current, captureResponseBody: false };
+        return this;
+    }
+    withoutNetworkCapture() {
+        this.options.networkCapture = false;
+        return this;
+    }
     withToolGuard(toolGuard) {
         this.options.toolGuard = toolGuard;
         return this;
@@ -621,6 +776,871 @@ function createOptionsBuilder(options = {}) {
     return new AnsightOptionsBuilder(options);
 }
 
+const networkRequestSchema = "ansight.network-request.v1";
+const redactedNetworkValue = "<redacted>";
+const maximumHeaderCount = 128;
+const maximumHeaderValueLength = 4096;
+const maximumErrorMessageLength = 4096;
+const maximumUrlLength = 16384;
+const defaultMaximumBodyBytes = 64 * 1024;
+const sensitiveHeaderNames = new Set([
+    "authorization",
+    "cookie",
+    "proxy-authorization",
+    "set-cookie",
+    "x-api-key",
+    "x-auth-token",
+]);
+const sensitiveQueryNames = new Set([
+    "access_token",
+    "accesskey",
+    "access_key",
+    "api_key",
+    "apikey",
+    "auth",
+    "authorization",
+    "client_secret",
+    "code",
+    "credential",
+    "credentials",
+    "id_token",
+    "jwt",
+    "key",
+    "password",
+    "passwd",
+    "refresh_token",
+    "sas",
+    "sastoken",
+    "secret",
+    "secret_key",
+    "security_token",
+    "session_token",
+    "sig",
+    "signature",
+    "token",
+]);
+const azureSasFingerprintNames = new Set([
+    "se",
+    "skoid",
+    "sp",
+    "sr",
+    "srt",
+    "ss",
+    "sv",
+]);
+const azureSasQueryNames = new Set([
+    "epk",
+    "erk",
+    "rscc",
+    "rscd",
+    "rsce",
+    "rscl",
+    "rsct",
+    "saoid",
+    "scid",
+    "se",
+    "sig",
+    "si",
+    "sip",
+    "ske",
+    "skoid",
+    "sks",
+    "skt",
+    "sktid",
+    "skv",
+    "snapshot",
+    "sp",
+    "spk",
+    "spr",
+    "sr",
+    "srk",
+    "srt",
+    "ss",
+    "st",
+    "suoid",
+    "tn",
+    "versionid",
+    "sv",
+]);
+function truncate(value, maximumLength) {
+    const text = String(value);
+    return text.length <= maximumLength
+        ? text
+        : `${text.slice(0, maximumLength)}…`;
+}
+function normalizeRequired(value, fallback, maximumLength) {
+    const normalized = value == null ? "" : String(value).trim();
+    return truncate(normalized || fallback, maximumLength);
+}
+function normalizeOptional(value, maximumLength) {
+    if (value == null)
+        return undefined;
+    const normalized = String(value).trim();
+    return normalized ? truncate(normalized, maximumLength) : undefined;
+}
+function lowercaseSet(values) {
+    return new Set((values ?? []).map((value) => value.toLowerCase()));
+}
+function isSensitiveHeader(name, options) {
+    const lowered = name.toLowerCase();
+    if (sensitiveHeaderNames.has(lowered) ||
+        lowercaseSet(options.additionalSensitiveHeaderNames).has(lowered)) {
+        return true;
+    }
+    const compact = lowered.replaceAll("-", "");
+    return (compact.includes("token") ||
+        compact.includes("secret") ||
+        compact.includes("apikey"));
+}
+function headerEntries(headers) {
+    if (!headers)
+        return [];
+    if (Array.isArray(headers)) {
+        return headers.flatMap((header) => {
+            if (Array.isArray(header))
+                return [[header[0], header[1]]];
+            if (header && typeof header === "object") {
+                const value = header;
+                return [[value.name, value.value]];
+            }
+            return [];
+        });
+    }
+    if (typeof headers.forEach === "function") {
+        const entries = [];
+        headers.forEach((value, name) => entries.push([name, value]));
+        return entries;
+    }
+    return typeof headers === "object" ? Object.entries(headers) : [];
+}
+function sanitizeHeaders(headers, options) {
+    return headerEntries(headers)
+        .filter(([name]) => name != null && String(name).trim())
+        .slice(0, maximumHeaderCount)
+        .map(([rawName, rawValue]) => {
+        const name = normalizeRequired(rawName, "Header", 256);
+        return {
+            name,
+            value: isSensitiveHeader(name, options)
+                ? redactedNetworkValue
+                : normalizeRequired(rawValue, "", maximumHeaderValueLength),
+        };
+    });
+}
+function sanitizeQuery(query, options) {
+    const appSensitive = lowercaseSet(options.additionalSensitiveQueryParameterNames);
+    const pairs = query.split("&");
+    const decodedNames = new Set(pairs.map((pair) => decodeQueryName(pair).toLowerCase()));
+    const hasAzureSas = decodedNames.has("sig") &&
+        [...azureSasFingerprintNames].some((name) => decodedNames.has(name));
+    const hasAwsSignature = decodedNames.has("x-amz-signature");
+    const hasGoogleSignature = decodedNames.has("x-goog-signature");
+    const hasCloudFrontSignature = decodedNames.has("signature") &&
+        ["key-pair-id", "policy", "expires"].some((name) => decodedNames.has(name));
+    const hasLegacyGoogleSignature = decodedNames.has("signature") && decodedNames.has("googleaccessid");
+    const hasAlibabaSignature = (decodedNames.has("signature") && decodedNames.has("ossaccesskeyid")) ||
+        decodedNames.has("x-oss-signature");
+    return pairs
+        .map((pair) => {
+        const equalsIndex = pair.indexOf("=");
+        const encodedName = equalsIndex < 0 ? pair : pair.slice(0, equalsIndex);
+        const decodedName = decodeQueryName(pair);
+        const lowered = decodedName.toLowerCase();
+        const providerSensitive = (hasAzureSas && azureSasQueryNames.has(lowered)) ||
+            (hasAwsSignature && lowered.startsWith("x-amz-")) ||
+            (hasGoogleSignature && lowered.startsWith("x-goog-")) ||
+            (hasCloudFrontSignature &&
+                [
+                    "signature",
+                    "key-pair-id",
+                    "policy",
+                    "expires",
+                    "hash-algorithm",
+                ].includes(lowered)) ||
+            (hasLegacyGoogleSignature &&
+                ["signature", "googleaccessid", "expires"].includes(lowered)) ||
+            (hasAlibabaSignature &&
+                (lowered.startsWith("x-oss-") ||
+                    ["signature", "ossaccesskeyid", "security-token"].includes(lowered)));
+        return providerSensitive ||
+            sensitiveQueryNames.has(lowered) ||
+            appSensitive.has(lowered)
+            ? `${encodedName}=${encodeURIComponent(redactedNetworkValue)}`
+            : pair;
+    })
+        .join("&");
+}
+function decodeQueryName(pair) {
+    const equalsIndex = pair.indexOf("=");
+    const encodedName = equalsIndex < 0 ? pair : pair.slice(0, equalsIndex);
+    try {
+        return decodeURIComponent(encodedName.replaceAll("+", " "));
+    }
+    catch {
+        return encodedName;
+    }
+}
+function sanitizeUrl(value, options) {
+    let normalized = normalizeRequired(value, "<unknown>", maximumUrlLength);
+    normalized = normalized.replace(/^(https?:\/\/)[^/@]+@/i, `$1${redactedNetworkValue}@`);
+    const queryIndex = normalized.indexOf("?");
+    if (queryIndex < 0)
+        return truncate(normalized, maximumUrlLength);
+    const fragmentIndex = normalized.indexOf("#", queryIndex);
+    if (options.includeQueryString === false) {
+        return truncate(normalized.slice(0, queryIndex) +
+            (fragmentIndex < 0 ? "" : normalized.slice(fragmentIndex)), maximumUrlLength);
+    }
+    const queryEnd = fragmentIndex < 0 ? normalized.length : fragmentIndex;
+    return truncate(normalized.slice(0, queryIndex + 1) +
+        sanitizeQuery(normalized.slice(queryIndex + 1, queryEnd), options) +
+        (fragmentIndex < 0 ? "" : normalized.slice(fragmentIndex)), maximumUrlLength);
+}
+function sanitizeErrorMessage(value, options) {
+    const normalized = normalizeOptional(value, maximumErrorMessageLength);
+    if (!normalized)
+        return undefined;
+    return truncate(normalized
+        .replace(/(access_token|api_key|apikey|auth|authorization|code|key|password|passwd|secret|signature|token)(\s*=\s*)([^&\s,;]+)/gi, `$1$2${redactedNetworkValue}`)
+        .replace(/https?:\/\/[^\s"'<>]+/gi, (url) => sanitizeUrl(url, options)), maximumErrorMessageLength);
+}
+function normalizeTimestamp(value, fallback) {
+    const date = new Date(value == null ? fallback : String(value));
+    return Number.isFinite(date.valueOf()) ? date.toISOString() : fallback;
+}
+function generateId(globalObject) {
+    if (typeof globalObject.crypto?.randomUUID === "function") {
+        return globalObject.crypto.randomUUID().replaceAll("-", "");
+    }
+    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}
+function normalizeSize(value) {
+    const number = Number(value);
+    return Number.isFinite(number) && number >= 0
+        ? Math.round(number)
+        : undefined;
+}
+function maximumBodyBytes(options) {
+    const configured = Number(options.maximumBodyBytes);
+    const value = Number.isFinite(configured)
+        ? Math.round(configured)
+        : defaultMaximumBodyBytes;
+    return Math.max(0, value);
+}
+function sanitizeSensitiveText(value, options) {
+    return value
+        .replace(/(access_token|accesskey|access_key|api_key|apikey|auth|authorization|client_secret|code|credential|credentials|id_token|jwt|key|password|passwd|refresh_token|sas|sastoken|secret|secret_key|security_token|session_token|sig|signature|token)(["']?\s*[:=]\s*["']?)([^&\s,;}"']+)/gi, `$1$2${redactedNetworkValue}`)
+        .replace(/https?:\/\/[^\s"'<>]+/gi, (url) => sanitizeUrl(url, options));
+}
+function truncateUtf8(bytes, maximum) {
+    let length = Math.min(bytes.length, maximum);
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    while (length > 0) {
+        try {
+            decoder.decode(bytes.slice(0, length));
+            return bytes.slice(0, length);
+        }
+        catch {
+            length -= 1;
+        }
+    }
+    return new Uint8Array();
+}
+function bytesToBase64$1(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function base64ToBytes(value) {
+    const binary = atob(value);
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function normalizeBody(body, options) {
+    const maximum = maximumBodyBytes(options);
+    if (!body || maximum <= 0)
+        return undefined;
+    const encoding = body.encoding?.toLowerCase();
+    let bytes;
+    try {
+        if (encoding === "utf8") {
+            bytes = new TextEncoder().encode(sanitizeSensitiveText(body.data, options));
+        }
+        else if (encoding === "base64" && options.captureBinaryBodies === true) {
+            bytes = base64ToBytes(body.data);
+        }
+        else {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    const originalLength = bytes.length;
+    const captured = encoding === "utf8"
+        ? truncateUtf8(bytes, maximum)
+        : bytes.slice(0, maximum);
+    const totalBytes = normalizeSize(body.totalBytes);
+    return {
+        contentType: normalizeOptional(body.contentType, 512),
+        encoding,
+        data: encoding === "base64"
+            ? bytesToBase64$1(captured)
+            : new TextDecoder().decode(captured),
+        capturedBytes: captured.length,
+        totalBytes,
+        truncated: body.truncated ||
+            originalLength > captured.length ||
+            (totalBytes != null && totalBytes > captured.length),
+    };
+}
+function normalizeRecord(input, options, globalObject) {
+    const now = new Date().toISOString();
+    const startedAtUtc = normalizeTimestamp(input.startedAtUtc, now);
+    const completedAtUtc = normalizeTimestamp(input.completedAtUtc, startedAtUtc);
+    const duration = Number(input.durationMilliseconds);
+    return {
+        schema: networkRequestSchema,
+        id: normalizeRequired(input.id, generateId(globalObject), 128),
+        source: normalizeRequired(input.source, "unknown", 128),
+        startedAtUtc,
+        completedAtUtc: completedAtUtc < startedAtUtc ? startedAtUtc : completedAtUtc,
+        durationMilliseconds: Number.isFinite(duration) && duration >= 0 ? duration : 0,
+        method: normalizeRequired(input.method, "GET", 32).toUpperCase(),
+        url: sanitizeUrl(input.url, options),
+        protocol: normalizeOptional(input.protocol, 64),
+        requestHeaders: options.includeRequestHeaders === false
+            ? []
+            : sanitizeHeaders(input.requestHeaders, options),
+        requestBodySizeBytes: options.includeBodySizes === false
+            ? undefined
+            : normalizeSize(input.requestBodySizeBytes),
+        requestBody: options.captureRequestBody !== false
+            ? normalizeBody(input.requestBody, options)
+            : undefined,
+        statusCode: Number.isInteger(Number(input.statusCode)) &&
+            Number(input.statusCode) >= 100 &&
+            Number(input.statusCode) <= 999
+            ? Number(input.statusCode)
+            : undefined,
+        reasonPhrase: normalizeOptional(input.reasonPhrase, 512),
+        responseHeaders: options.includeResponseHeaders === false
+            ? []
+            : sanitizeHeaders(input.responseHeaders, options),
+        responseBodySizeBytes: options.includeBodySizes === false
+            ? undefined
+            : normalizeSize(input.responseBodySizeBytes),
+        responseBody: options.captureResponseBody !== false
+            ? normalizeBody(input.responseBody, options)
+            : undefined,
+        errorType: normalizeOptional(input.errorType, 512),
+        errorMessage: sanitizeErrorMessage(input.errorMessage, options),
+    };
+}
+function sanitizeNetworkRequest(input, options = {}, globalObject = globalThis) {
+    try {
+        let normalized = normalizeRecord(input, options, globalObject);
+        if (options.urlSanitizer) {
+            normalized = normalizeRecord({ ...normalized, url: options.urlSanitizer(normalized.url) }, options, globalObject);
+        }
+        if (options.requestSanitizer) {
+            const transformed = options.requestSanitizer(normalized);
+            if (transformed == null)
+                return null;
+            normalized = normalizeRecord(transformed, options, globalObject);
+        }
+        return normalized;
+    }
+    catch {
+        return null;
+    }
+}
+function parseContentLength(headers) {
+    const entry = headerEntries(headers).find(([name]) => String(name).toLowerCase() === "content-length");
+    return entry ? normalizeSize(entry[1]) : undefined;
+}
+function headerValue(headers, wantedName) {
+    const entry = headerEntries(headers).find(([name]) => String(name).toLowerCase() === wantedName);
+    return entry == null ? undefined : String(entry[1]);
+}
+function isTextContentType(contentType) {
+    if (!contentType)
+        return true;
+    const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
+    return (mediaType.startsWith("text/") ||
+        mediaType.endsWith("+json") ||
+        mediaType.endsWith("+xml") ||
+        [
+            "application/json",
+            "application/xml",
+            "application/graphql",
+            "application/javascript",
+            "application/x-www-form-urlencoded",
+        ].includes(mediaType));
+}
+function bodyFromBytes(bytes, totalBytes, contentType, options) {
+    const binary = !isTextContentType(contentType);
+    if (binary && options.captureBinaryBodies !== true)
+        return undefined;
+    const maximum = maximumBodyBytes(options);
+    if (maximum <= 0)
+        return undefined;
+    const captured = binary
+        ? bytes.slice(0, maximum)
+        : truncateUtf8(bytes, maximum);
+    return {
+        contentType,
+        encoding: binary ? "base64" : "utf8",
+        data: binary ? bytesToBase64$1(captured) : new TextDecoder().decode(captured),
+        capturedBytes: captured.length,
+        totalBytes,
+        truncated: bytes.length > captured.length ||
+            (totalBytes != null && totalBytes > captured.length),
+    };
+}
+function bodyFromValue(value, headers, options) {
+    if (value == null || options.captureRequestBody === false)
+        return undefined;
+    const contentType = headerValue(headers, "content-type");
+    if (typeof value === "string" || value instanceof URLSearchParams) {
+        const bytes = new TextEncoder().encode(String(value));
+        return bodyFromBytes(bytes, bytes.length, contentType ||
+            (value instanceof URLSearchParams
+                ? "application/x-www-form-urlencoded"
+                : undefined), options);
+    }
+    if (value instanceof ArrayBuffer) {
+        const bytes = new Uint8Array(value);
+        return bodyFromBytes(bytes, bytes.length, contentType, options);
+    }
+    if (ArrayBuffer.isView(value)) {
+        const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+        return bodyFromBytes(bytes, bytes.length, contentType, options);
+    }
+    return undefined;
+}
+async function bodyFromFetchResponse(response, headers, options, shouldContinue = () => true) {
+    if (!shouldContinue() || options.captureResponseBody === false)
+        return undefined;
+    const contentType = headerValue(headers, "content-type");
+    if (!isTextContentType(contentType) && options.captureBinaryBodies !== true) {
+        return undefined;
+    }
+    const totalBytes = parseContentLength(headers);
+    const maximum = maximumBodyBytes(options);
+    if (maximum <= 0)
+        return undefined;
+    const clone = response.clone();
+    if (clone.body) {
+        const reader = clone.body.getReader();
+        const chunks = [];
+        let capturedLength = 0;
+        let observedLength = 0;
+        try {
+            while (capturedLength <= maximum) {
+                if (!shouldContinue()) {
+                    await reader.cancel().catch(() => undefined);
+                    return undefined;
+                }
+                const result = await reader.read();
+                if (!shouldContinue()) {
+                    await reader.cancel().catch(() => undefined);
+                    return undefined;
+                }
+                if (result.done)
+                    break;
+                const chunk = result.value;
+                observedLength += chunk.length;
+                const remaining = maximum - capturedLength;
+                if (remaining > 0) {
+                    const kept = chunk.slice(0, remaining);
+                    chunks.push(kept);
+                    capturedLength += kept.length;
+                }
+                if (observedLength > maximum) {
+                    await reader.cancel().catch(() => undefined);
+                    break;
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const joined = new Uint8Array(capturedLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            joined.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return bodyFromBytes(joined, totalBytes ?? observedLength, contentType, options);
+    }
+    if (totalBytes == null || totalBytes > maximum)
+        return undefined;
+    const bytes = new Uint8Array(await clone.arrayBuffer());
+    if (!shouldContinue())
+        return undefined;
+    return bodyFromBytes(bytes, totalBytes, contentType, options);
+}
+function parseXhrResponseHeaders(value) {
+    return value
+        .trim()
+        .split(/[\r\n]+/)
+        .flatMap((line) => {
+        const separator = line.indexOf(":");
+        return separator < 0
+            ? []
+            : [
+                {
+                    name: line.slice(0, separator),
+                    value: line.slice(separator + 1),
+                },
+            ];
+    });
+}
+function monotonicNow(globalObject) {
+    return typeof globalObject.performance?.now === "function"
+        ? globalObject.performance.now()
+        : Date.now();
+}
+function installBrowserNetworkCapture(capture, options = {}, sourcePrefix = "capacitor", globalObject = globalThis) {
+    const cleanups = [];
+    let active = true;
+    let fetchInvocationDepth = 0;
+    if (options.captureFetch !== false &&
+        typeof globalObject.fetch === "function") {
+        const originalFetch = globalObject.fetch;
+        const wrappedFetch = function (input, init) {
+            const startedAtUtc = new Date().toISOString();
+            const started = monotonicNow(globalObject);
+            const inputRequest = typeof input === "object" && "headers" in input && "method" in input
+                ? input
+                : undefined;
+            const requestHeaders = headerEntries(inputRequest?.headers).concat(headerEntries(init?.headers));
+            const requestBody = bodyFromValue(init?.body, requestHeaders, options);
+            const method = init?.method || inputRequest?.method || "GET";
+            const url = typeof input === "string" ? input : inputRequest?.url || String(input);
+            let promise;
+            fetchInvocationDepth += 1;
+            try {
+                promise = originalFetch(input, init);
+            }
+            catch (error) {
+                fetchInvocationDepth -= 1;
+                const request = sanitizeNetworkRequest({
+                    source: `${sourcePrefix}.fetch`,
+                    startedAtUtc,
+                    completedAtUtc: new Date().toISOString(),
+                    durationMilliseconds: monotonicNow(globalObject) - started,
+                    method,
+                    url,
+                    requestHeaders: sanitizeHeaders(requestHeaders, {}),
+                    requestBodySizeBytes: parseContentLength(requestHeaders) ?? requestBody?.totalBytes,
+                    requestBody,
+                    errorType: error instanceof Error ? error.name : "Error",
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                }, options, globalObject);
+                if (active && request)
+                    Promise.resolve(capture(request)).catch(() => undefined);
+                throw error;
+            }
+            fetchInvocationDepth -= 1;
+            return promise.then((response) => {
+                if (!active)
+                    return response;
+                const responseHeaders = headerEntries(response.headers);
+                const responseRecord = {
+                    source: `${sourcePrefix}.fetch`,
+                    startedAtUtc,
+                    completedAtUtc: new Date().toISOString(),
+                    durationMilliseconds: monotonicNow(globalObject) - started,
+                    method,
+                    url: response.url || url,
+                    requestHeaders: sanitizeHeaders(requestHeaders, {}),
+                    requestBodySizeBytes: parseContentLength(requestHeaders) ?? requestBody?.totalBytes,
+                    requestBody,
+                    statusCode: response.status,
+                    reasonPhrase: response.statusText,
+                    responseHeaders: sanitizeHeaders(responseHeaders, {}),
+                    responseBodySizeBytes: parseContentLength(responseHeaders),
+                };
+                return bodyFromFetchResponse(response, responseHeaders, options, () => active).then((responseBody) => {
+                    const request = sanitizeNetworkRequest({
+                        ...responseRecord,
+                        responseBody,
+                        responseBodySizeBytes: responseRecord.responseBodySizeBytes ??
+                            responseBody?.totalBytes,
+                    }, options, globalObject);
+                    if (active && request)
+                        void Promise.resolve(capture(request)).catch(() => undefined);
+                    return response;
+                }, () => {
+                    const request = sanitizeNetworkRequest(responseRecord, options, globalObject);
+                    if (active && request)
+                        void Promise.resolve(capture(request)).catch(() => undefined);
+                    return response;
+                });
+            }, (error) => {
+                const request = sanitizeNetworkRequest({
+                    source: `${sourcePrefix}.fetch`,
+                    startedAtUtc,
+                    completedAtUtc: new Date().toISOString(),
+                    durationMilliseconds: monotonicNow(globalObject) - started,
+                    method,
+                    url,
+                    requestHeaders: sanitizeHeaders(requestHeaders, {}),
+                    requestBodySizeBytes: parseContentLength(requestHeaders) ?? requestBody?.totalBytes,
+                    requestBody,
+                    errorType: error instanceof Error ? error.name : "Error",
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                }, options, globalObject);
+                if (active && request)
+                    Promise.resolve(capture(request)).catch(() => undefined);
+                throw error;
+            });
+        };
+        globalObject.fetch = wrappedFetch;
+        cleanups.push(() => {
+            if (globalObject.fetch === wrappedFetch)
+                globalObject.fetch = originalFetch;
+        });
+    }
+    const Xhr = globalObject.XMLHttpRequest;
+    if (options.captureXmlHttpRequest !== false && Xhr?.prototype) {
+        const states = new WeakMap();
+        const prototype = Xhr.prototype;
+        const originalOpen = prototype.open;
+        const originalSend = prototype.send;
+        const originalSetRequestHeader = prototype.setRequestHeader;
+        const wrappedOpen = function (method, url, ...rest) {
+            states.set(this, {
+                method,
+                url: String(url),
+                requestHeaders: [],
+                suppressed: fetchInvocationDepth > 0,
+            });
+            Reflect.apply(originalOpen, this, [method, url, ...rest]);
+        };
+        const wrappedSetRequestHeader = function (name, value) {
+            states.get(this)?.requestHeaders.push({ name, value });
+            Reflect.apply(originalSetRequestHeader, this, [name, value]);
+        };
+        const wrappedSend = function (body) {
+            const state = states.get(this);
+            if (!state || state.suppressed) {
+                Reflect.apply(originalSend, this, [body]);
+                return;
+            }
+            state.startedAtUtc = new Date().toISOString();
+            state.started = monotonicNow(globalObject);
+            state.requestBody = bodyFromValue(body, state.requestHeaders, options);
+            let failure;
+            const markFailure = (event) => {
+                failure = event.type;
+            };
+            const complete = () => {
+                if (!active)
+                    return;
+                let responseHeaders = [];
+                try {
+                    responseHeaders = parseXhrResponseHeaders(this.getAllResponseHeaders());
+                }
+                catch {
+                    // Some WebViews throw before response headers exist.
+                }
+                let responseBody;
+                try {
+                    const responseType = this.responseType || "text";
+                    const responseOptions = {
+                        ...options,
+                        captureRequestBody: options.captureResponseBody,
+                    };
+                    if (responseType === "text") {
+                        responseBody = bodyFromValue(this.responseText, responseHeaders, responseOptions);
+                    }
+                    else if (responseType === "arraybuffer") {
+                        responseBody = bodyFromValue(this.response, responseHeaders, responseOptions);
+                    }
+                }
+                catch {
+                    // Response data is not readable for every XHR response type.
+                }
+                const request = sanitizeNetworkRequest({
+                    source: `${sourcePrefix}.xhr`,
+                    startedAtUtc: state.startedAtUtc,
+                    completedAtUtc: new Date().toISOString(),
+                    durationMilliseconds: monotonicNow(globalObject) - (state.started ?? 0),
+                    method: state.method,
+                    url: this.responseURL || state.url,
+                    requestHeaders: state.requestHeaders,
+                    requestBodySizeBytes: parseContentLength(state.requestHeaders) ??
+                        state.requestBody?.totalBytes,
+                    requestBody: state.requestBody,
+                    statusCode: this.status || undefined,
+                    reasonPhrase: this.statusText,
+                    responseHeaders,
+                    responseBodySizeBytes: parseContentLength(responseHeaders) ?? responseBody?.totalBytes,
+                    responseBody,
+                    errorType: failure,
+                    errorMessage: failure ? `XMLHttpRequest ${failure}` : undefined,
+                }, options, globalObject);
+                if (request)
+                    Promise.resolve(capture(request)).catch(() => undefined);
+            };
+            this.addEventListener("error", markFailure);
+            this.addEventListener("abort", markFailure);
+            this.addEventListener("timeout", markFailure);
+            this.addEventListener("loadend", complete, { once: true });
+            Reflect.apply(originalSend, this, [body]);
+        };
+        prototype.open = wrappedOpen;
+        prototype.setRequestHeader = wrappedSetRequestHeader;
+        prototype.send = wrappedSend;
+        cleanups.push(() => {
+            if (prototype.open === wrappedOpen)
+                prototype.open = originalOpen;
+            if (prototype.send === wrappedSend)
+                prototype.send = originalSend;
+            if (prototype.setRequestHeader === wrappedSetRequestHeader) {
+                prototype.setRequestHeader = originalSetRequestHeader;
+            }
+        });
+    }
+    let removed = false;
+    return {
+        remove() {
+            if (removed)
+                return;
+            removed = true;
+            active = false;
+            for (const cleanup of cleanups.reverse())
+                cleanup();
+        },
+    };
+}
+
+const ANSIGHT_CAPACITOR_SDK_VERSION = "1.3.0-preview.11";
+const COMPILED_CAPACITOR_CORE_VERSION = "8.4.2";
+const CAPACITOR_GROUP = "capacitor";
+const LOCALIZATION_GROUP = "localization";
+function normalized(value) {
+    if (value == null)
+        return undefined;
+    const result = String(value).trim();
+    return result || undefined;
+}
+function canonicalizeLocale(value) {
+    const locale = normalized(value)?.replace(/_/g, "-");
+    if (!locale)
+        return undefined;
+    try {
+        return Intl.getCanonicalLocales(locale)[0] ?? locale;
+    }
+    catch {
+        return locale;
+    }
+}
+function parseLocale(locale) {
+    const parts = (locale ?? "").split("-").filter(Boolean);
+    const language = parts[0]?.toLowerCase();
+    const region = parts.find((part, index) => index > 0 && (/^[A-Za-z]{2}$/.test(part) || /^\d{3}$/.test(part)));
+    return { language, region: region?.toUpperCase() };
+}
+function webViewDetails(platform, nativePlatform, userAgent) {
+    const agent = userAgent ?? "";
+    if (nativePlatform && platform === "ios") {
+        return {
+            engine: "wkWebView",
+            version: /AppleWebKit\/([^\s]+)/.exec(agent)?.[1],
+        };
+    }
+    if (nativePlatform && platform === "android") {
+        return {
+            engine: "chromiumWebView",
+            version: /(?:Chrome|Chromium)\/([^\s]+)/.exec(agent)?.[1],
+        };
+    }
+    if (/Firefox\/([^\s]+)/.test(agent)) {
+        return { engine: "gecko", version: /Firefox\/([^\s]+)/.exec(agent)?.[1] };
+    }
+    if (/(?:Chrome|Chromium)\/([^\s]+)/.test(agent)) {
+        return {
+            engine: "chromium",
+            version: /(?:Chrome|Chromium)\/([^\s]+)/.exec(agent)?.[1],
+        };
+    }
+    if (/AppleWebKit\/([^\s]+)/.test(agent)) {
+        return {
+            engine: "webkit",
+            version: /AppleWebKit\/([^\s]+)/.exec(agent)?.[1],
+        };
+    }
+    return { engine: "unknown" };
+}
+function currentCapacitorSessionEnvironment(platform, nativePlatform) {
+    let resolved;
+    try {
+        resolved = Intl.DateTimeFormat().resolvedOptions();
+    }
+    catch {
+        resolved = undefined;
+    }
+    return {
+        platform,
+        nativePlatform,
+        userAgent: typeof navigator === "undefined" ? undefined : navigator.userAgent,
+        locale: resolved?.locale ??
+            (typeof navigator === "undefined" ? undefined : navigator.language),
+        timeZone: resolved?.timeZone,
+        utcOffsetMinutes: -new Date().getTimezoneOffset(),
+    };
+}
+function createAutomaticSessionProperties(environment) {
+    const platform = normalized(environment.platform) ?? "unknown";
+    const userAgent = normalized(environment.userAgent);
+    const webView = webViewDetails(platform, environment.nativePlatform, userAgent);
+    const locale = canonicalizeLocale(environment.locale);
+    const parsedLocale = parseLocale(locale);
+    const capacitor = {
+        sdkVersion: ANSIGHT_CAPACITOR_SDK_VERSION,
+        capacitorVersion: "8.x",
+        compiledCapacitorVersion: COMPILED_CAPACITOR_CORE_VERSION,
+        platform,
+        runtimeLanguage: "javascript",
+        executionMode: environment.nativePlatform ? "native" : "web",
+        webViewEngine: webView.engine,
+    };
+    if (webView.version)
+        capacitor.webViewEngineVersion = webView.version;
+    if (userAgent)
+        capacitor.userAgent = userAgent;
+    const localization = {
+        utcOffsetMinutes: String(environment.utcOffsetMinutes ?? -new Date().getTimezoneOffset()),
+    };
+    if (locale)
+        localization.locale = locale;
+    if (parsedLocale.language)
+        localization.language = parsedLocale.language;
+    if (parsedLocale.region)
+        localization.region = parsedLocale.region;
+    if (normalized(environment.timeZone)) {
+        localization.timeZone = String(environment.timeZone).trim();
+    }
+    return {
+        [CAPACITOR_GROUP]: capacitor,
+        [LOCALIZATION_GROUP]: localization,
+    };
+}
+function mergeSessionProperties(automaticProperties, customProperties) {
+    const merged = Object.fromEntries(Object.entries(automaticProperties).map(([group, properties]) => [
+        group,
+        { ...properties },
+    ]));
+    for (const [group, properties] of Object.entries(customProperties ?? {})) {
+        merged[group] = { ...(merged[group] ?? {}), ...properties };
+    }
+    return merged;
+}
+
 const AnsightNative = core.registerPlugin("Ansight");
 const toolHandlers = new Map();
 const artifactProviders = new Map();
@@ -631,6 +1651,9 @@ let logListener;
 let lifecycleCleanup;
 let artifactToolRegistrations = [];
 let domToolRegistration;
+let networkCaptureSubscription;
+let networkCaptureRegistration;
+let networkConnectionListener;
 function normalizePairingPayload(payload) {
     if (payload == null)
         return payload;
@@ -638,11 +1661,19 @@ function normalizePairingPayload(payload) {
 }
 function normalizeOptions(input) {
     const options = JSON.parse(JSON.stringify(input));
+    options.customProperties = mergeSessionProperties(automaticSessionProperties(), options.customProperties);
     delete options.domTools;
     delete options.errorCapture;
     delete options.lifecycle;
+    delete options.networkCapture;
     return options;
 }
+function automaticSessionProperties() {
+    return createAutomaticSessionProperties(currentCapacitorSessionEnvironment(core.Capacitor.getPlatform(), core.Capacitor.isNativePlatform()));
+}
+function automaticSessionPropertyValue(group, key) {
+    return automaticSessionProperties()[group]?.[key];
+}
 function normalizeToolResult(value) {
     if (value && typeof value === "object" && "success" in value) {
         return value;
@@ -692,11 +1723,13 @@ async function emitHostConnectionStatus() {
 }
 async function afterConnectionChange(operation) {
     const result = await operation();
+    await refreshNetworkCaptureConnection();
     await emitHostConnectionStatus();
     return result;
 }
 async function initialize(options = {}) {
     const result = await AnsightNative.initialize(normalizeOptions(options));
+    await configureNetworkCapture(options.networkCapture);
     if (options.lifecycle !== false)
         startLifecycleTracking();
     if (options.errorCapture) {
@@ -710,6 +1743,7 @@ async function initialize(options = {}) {
 }
 async function initializeAndActivate(options = {}) {
     const result = await AnsightNative.initializeAndActivate(normalizeOptions(options));
+    await configureNetworkCapture(options.networkCapture);
     if (options.lifecycle !== false)
         startLifecycleTracking();
     if (options.errorCapture) {
@@ -734,6 +1768,81 @@ function event(input) {
     return AnsightNative.recordEvent(typeof input === "string" ? { label: input } : input);
 }
 const recordEvent = event;
+async function recordNetworkRequest(input, sanitizationOptions = {}) {
+    const request = sanitizeNetworkRequest(input, sanitizationOptions);
+    if (!request) {
+        return {
+            success: false,
+            message: "Network request capture was suppressed by the sanitizer.",
+        };
+    }
+    return AnsightNative.recordNetworkRequest(request);
+}
+function installNetworkCapture(options = {}) {
+    uninstallNetworkCapture();
+    const registration = { options };
+    networkCaptureRegistration = registration;
+    ensureNetworkConnectionListener();
+    void refreshNetworkCaptureConnection();
+    return {
+        remove() {
+            if (networkCaptureRegistration === registration) {
+                uninstallNetworkCapture();
+            }
+        },
+    };
+}
+function uninstallNetworkCapture() {
+    networkCaptureRegistration = undefined;
+    const listener = networkConnectionListener;
+    networkConnectionListener = undefined;
+    if (listener)
+        void listener.then((value) => value.remove());
+    detachNetworkCapture();
+}
+function detachNetworkCapture() {
+    networkCaptureSubscription?.remove();
+    networkCaptureSubscription = undefined;
+}
+async function refreshNetworkCaptureConnection() {
+    const registration = networkCaptureRegistration;
+    if (!registration) {
+        detachNetworkCapture();
+        return;
+    }
+    try {
+        const status = await AnsightNative.hostConnectionStatus();
+        if (networkCaptureRegistration !== registration)
+            return;
+        applyNetworkConnectionStatus(status);
+    }
+    catch {
+        if (networkCaptureRegistration === registration)
+            detachNetworkCapture();
+    }
+}
+function ensureNetworkConnectionListener() {
+    networkConnectionListener ??= AnsightNative.addListener("ansightHostConnectionStatus", applyNetworkConnectionStatus);
+}
+function applyNetworkConnectionStatus(status) {
+    const registration = networkCaptureRegistration;
+    if (!registration || status.isConnected !== true) {
+        detachNetworkCapture();
+        return;
+    }
+    networkCaptureSubscription ??= installBrowserNetworkCapture((request) => AnsightNative.recordNetworkRequest(request), registration.options);
+}
+async function configureNetworkCapture(value) {
+    uninstallNetworkCapture();
+    if (!value)
+        return;
+    networkCaptureRegistration = {
+        options: typeof value === "object" ? value : {},
+    };
+    ensureNetworkConnectionListener();
+    await refreshNetworkCaptureConnection();
+}
+const recordCrashCandidate = (input) => AnsightNative.recordCrashCandidate(input);
 const screenViewed = (name, details = {}) => AnsightNative.screenViewed({ name, details });
 const trackRoute = screenViewed;
 const setAppLifecycleState = (state) => AnsightNative.setAppLifecycleState({ state });
@@ -788,12 +1897,25 @@ const disableFramesPerSecond = () => AnsightNative.disableFramesPerSecond();
 const captureScreenFrame = (options = {}) => AnsightNative.captureScreenFrame(options);
 const enableTouchCapture = () => AnsightNative.enableTouchCapture();
 const disableTouchCapture = () => AnsightNative.disableTouchCapture();
-const updateSessionProperties = (properties) => AnsightNative.updateSessionProperties({ properties });
+const updateSessionProperties = (properties) => AnsightNative.updateSessionProperties({
+    properties: mergeSessionProperties(automaticSessionProperties(), properties),
+});
 const updateCustomProperties = updateSessionProperties;
-const clearSessionProperties = () => AnsightNative.clearSessionProperties();
+const clearSessionProperties = () => AnsightNative.updateSessionProperties({
+    properties: automaticSessionProperties(),
+});
 const clearCustomProperties = clearSessionProperties;
 const registerCustomProperty = (group, key, value) => AnsightNative.registerCustomProperty({ group, key, value });
-const removeCustomProperty = (group, key) => AnsightNative.removeCustomProperty({ group, key });
+const removeCustomProperty = (group, key) => {
+    const automaticValue = automaticSessionPropertyValue(group, key);
+    return automaticValue == null
+        ? AnsightNative.removeCustomProperty({ group, key })
+        : AnsightNative.registerCustomProperty({
+            group,
+            key,
+            value: automaticValue,
+        });
+};
 function addHostConnectionStatusListener(listener, options = {}) {
     hostConnectionListeners.add(listener);
     if (options.emitCurrent !== false)
@@ -1039,6 +2161,18 @@ function installErrorHandlers(options = {}) {
     const onError = (eventValue) => {
         if (!captureErrors)
             return;
+        void recordCrashCandidate({
+            runtime: "capacitor-javascript",
+            kind: "unhandled_javascript_error",
+            message: eventValue.message,
+            stack: eventValue.error instanceof Error ? eventValue.error.stack : undefined,
+            fatal: false,
+            metadata: JSON.stringify({
+                filename: eventValue.filename,
+                line: eventValue.lineno,
+                column: eventValue.colno,
+            }),
+        }).catch(() => undefined);
         void event({
             label: eventValue.message || "Unhandled JavaScript error",
             type: "Exception",
@@ -1056,6 +2190,13 @@ function installErrorHandlers(options = {}) {
         if (!captureRejections)
             return;
         const reason = eventValue.reason;
+        void recordCrashCandidate({
+            runtime: "capacitor-javascript",
+            kind: "unhandled_promise_rejection",
+            message: reason instanceof Error ? reason.message : String(reason),
+            stack: reason instanceof Error ? reason.stack : undefined,
+            fatal: false,
+        }).catch(() => undefined);
         void event({
             label: reason instanceof Error
                 ? reason.message
@@ -1125,6 +2266,10 @@ const Ansight = {
     recordMetric,
     event,
     recordEvent,
+    recordNetworkRequest,
+    installNetworkCapture,
+    uninstallNetworkCapture,
+    sanitizeNetworkRequest,
     screenViewed,
     trackRoute,
     setAppLifecycleState,
@@ -1222,14 +2367,17 @@ exports.initialize = initialize;
 exports.initializeAndActivate = initializeAndActivate;
 exports.installDomTools = installDomTools;
 exports.installErrorHandlers = installErrorHandlers;
+exports.installNetworkCapture = installNetworkCapture;
 exports.isFramesPerSecondEnabled = isFramesPerSecondEnabled;
 exports.listRegisteredArtifactProviders = listRegisteredArtifactProviders;
 exports.listRegisteredTools = listRegisteredTools;
 exports.metric = metric;
 exports.notifyHostConnectionConfigChanged = notifyHostConnectionConfigChanged;
 exports.openSession = openSession;
+exports.recordCrashCandidate = recordCrashCandidate;
 exports.recordEvent = recordEvent;
 exports.recordMetric = recordMetric;
+exports.recordNetworkRequest = recordNetworkRequest;
 exports.recordedEvents = recordedEvents;
 exports.recordedMetrics = recordedMetrics;
 exports.registerArtifactProvider = registerArtifactProvider;
@@ -1238,6 +2386,7 @@ exports.registerCustomProperty = registerCustomProperty;
 exports.registerMetricChannel = registerMetricChannel;
 exports.registerTool = registerTool;
 exports.removeCustomProperty = removeCustomProperty;
+exports.sanitizeNetworkRequest = sanitizeNetworkRequest;
 exports.savePairingConfig = savePairingConfig;
 exports.scanPairingQrCode = scanPairingQrCode;
 exports.screenViewed = screenViewed;
@@ -1251,6 +2400,7 @@ exports.stopAppStateTracking = stopAppStateTracking;
 exports.stopLifecycleTracking = stopLifecycleTracking;
 exports.trackRoute = trackRoute;
 exports.uninstallDomTools = uninstallDomTools;
+exports.uninstallNetworkCapture = uninstallNetworkCapture;
 exports.unregisterArtifactProvider = unregisterArtifactProvider;
 exports.unregisterTool = unregisterTool;
 exports.updateCustomProperties = updateCustomProperties;