@ansight/capacitor 1.3.0-preview.8 → 1.4.0-preview.1

package/dist/standalone.js

@@ -700,6 +700,19 @@
             element.id ??
             undefined)?.trim() || undefined);
     }
+    const tapRoles = new Set([
+        "button",
+        "checkbox",
+        "combobox",
+        "link",
+        "menuitem",
+        "menuitemcheckbox",
+        "menuitemradio",
+        "option",
+        "radio",
+        "switch",
+        "tab",
+    ]);
     function semanticRole(element) {
         const declared = element.getAttribute("role")?.trim().toLowerCase();
         if (declared)
@@ -731,24 +744,54 @@
         if (!allowActions)
             return [];
         const actions = [];
+        const htmlElement = element;
+        const role = semanticRole(element);
         if (["A", "BUTTON", "SUMMARY"].includes(element.tagName) ||
-            element instanceof HTMLInputElement) {
+            element instanceof HTMLInputElement ||
+            tapRoles.has(role) ||
+            element.hasAttribute("onclick") ||
+            typeof htmlElement.onclick === "function") {
             actions.push("tap");
         }
         if (element instanceof HTMLInputElement ||
             element instanceof HTMLTextAreaElement ||
-            element instanceof HTMLSelectElement) {
+            element instanceof HTMLSelectElement ||
+            htmlElement.isContentEditable) {
             actions.push("typeText", "focus");
         }
-        else if (element.tabIndex >= 0) {
+        else if (htmlElement.tabIndex >= 0) {
             actions.push("focus");
         }
-        if (element.scrollHeight >
-            element.clientHeight) {
+        if (htmlElement.scrollHeight > htmlElement.clientHeight ||
+            htmlElement.scrollWidth > htmlElement.clientWidth) {
             actions.push("scroll", "swipe");
         }
         return [...new Set(actions)];
     }
+    function positiveFinite(value) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+    }
+    function createDomCoordinateSpace(browserWindow = typeof window === "undefined"
+        ? undefined
+        : window, documentElement = typeof document === "undefined"
+        ? null
+        : document.documentElement) {
+        const width = positiveFinite(browserWindow?.innerWidth) ??
+            positiveFinite(documentElement?.clientWidth);
+        const height = positiveFinite(browserWindow?.innerHeight) ??
+            positiveFinite(documentElement?.clientHeight);
+        if (width === undefined || height === undefined)
+            return undefined;
+        return { x: 0, y: 0, width, height, source: "dom.viewport" };
+    }
+    function normalizeDomAction(action) {
+        if (action === "tap")
+            return "click";
+        if (action === "typeText")
+            return "setValue";
+        return String(action ?? "");
+    }
     function computedColorToArgbHex(value) {
         const normalized = value.trim().toLowerCase();
         if (!normalized)
@@ -897,8 +940,7 @@
                 name: "Get DOM document",
                 description: "Returns the accessible HTML DOM tree rendered inside the Capacitor WebView.",
                 category: "UI",
-                scope: "read",
-                security: { level: "low", summary: "Reads the current app DOM." },
+                policy: "read",
             }, async () => {
                 const root = document.documentElement;
                 const limits = {
@@ -913,6 +955,7 @@
                     platform: "web",
                     source: options.source,
                     adapter: "@ansight/capacitor",
+                    coordinateSpace: createDomCoordinateSpace(),
                     capturedAtUtc: new Date().toISOString(),
                     types: typeRegistry.types,
                     truncated: limits.count >= limits.maxNodes,
@@ -924,7 +967,7 @@
                 name: "Inspect DOM node",
                 description: "Returns the current state of a DOM node captured by dom.get_document.",
                 category: "UI",
-                scope: "read",
+                policy: "read",
                 argumentsSchema: {
                     type: "object",
                     required: ["nodeId"],
@@ -947,6 +990,7 @@
                     platform: "web",
                     source: options.source,
                     adapter: "@ansight/capacitor",
+                    coordinateSpace: createDomCoordinateSpace(),
                     capturedAtUtc: new Date().toISOString(),
                     types: typeRegistry.types,
                     node,
@@ -957,7 +1001,7 @@
                 name: "Query DOM",
                 description: "Finds DOM nodes using a CSS selector.",
                 category: "UI",
-                scope: "read",
+                policy: "read",
                 argumentsSchema: {
                     type: "object",
                     required: ["selector"],
@@ -985,22 +1029,21 @@
             registrations.push(registerTool({
                 id: "dom.invoke_action",
                 name: "Invoke DOM action",
-                description: "Clicks, focuses, blurs, or changes a DOM node.",
+                description: "Taps, focuses, blurs, or enters text in a DOM node.",
                 category: "UI",
-                scope: "write",
+                policy: "write",
                 argumentsSchema: {
                     type: "object",
                     required: ["nodeId", "action"],
                     properties: {
                         nodeId: { type: "string" },
-                        action: { enum: ["click", "focus", "blur", "setValue"] },
+                        action: {
+                            type: "string",
+                            enum: ["tap", "typeText", "click", "focus", "blur", "setValue"],
+                        },
                         value: { type: "string" },
                     },
                 },
-                security: {
-                    level: "high",
-                    summary: "Can interact with controls inside the app WebView.",
-                },
             }, ({ nodeId: id, action, value }) => {
                 const element = findElement(id);
                 if (!element) {
@@ -1010,17 +1053,24 @@
                         errorCode: "dom_node_not_found",
                     };
                 }
-                if (action === "click")
+                const normalizedAction = normalizeDomAction(action);
+                if (normalizedAction === "click")
                     element.click();
-                else if (action === "focus")
+                else if (normalizedAction === "focus")
                     element.focus();
-                else if (action === "blur")
+                else if (normalizedAction === "blur")
                     element.blur();
-                else if (action === "setValue" &&
+                else if (normalizedAction === "setValue" &&
                     (element instanceof HTMLInputElement ||
                         element instanceof HTMLTextAreaElement ||
-                        element instanceof HTMLSelectElement)) {
-                    element.value = value ?? "";
+                        element instanceof HTMLSelectElement ||
+                        element.isContentEditable)) {
+                    if (element.isContentEditable) {
+                        element.textContent = value ?? "";
+                    }
+                    else {
+                        element.value = value ?? "";
+                    }
                     element.dispatchEvent(new Event("input", { bubbles: true }));
                     element.dispatchEvent(new Event("change", { bubbles: true }));
                 }
@@ -1031,7 +1081,7 @@
                         errorCode: "dom_action_unsupported",
                     };
                 }
-                return successful({ nodeId: id, action }, `DOM action '${action}' invoked.`);
+                return successful({ nodeId: id, action, performedAction: normalizedAction }, `DOM action '${action}' invoked.`);
             }));
         }
         return {
@@ -1203,6 +1253,50 @@
             };
             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;
@@ -1370,6 +1464,871 @@
         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.4.0-preview.1";
+    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 = registerPlugin("Ansight");
     const toolHandlers = new Map();
     const artifactProviders = new Map();
@@ -1380,6 +2339,9 @@
     let lifecycleCleanup;
     let artifactToolRegistrations = [];
     let domToolRegistration;
+    let networkCaptureSubscription;
+    let networkCaptureRegistration;
+    let networkConnectionListener;
     function normalizePairingPayload(payload) {
         if (payload == null)
             return payload;
@@ -1387,11 +2349,19 @@
     }
     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(Capacitor.getPlatform(), Capacitor.isNativePlatform()));
+    }
+    function automaticSessionPropertyValue(group, key) {
+        return automaticSessionProperties()[group]?.[key];
+    }
     function normalizeToolResult(value) {
         if (value && typeof value === "object" && "success" in value) {
             return value;
@@ -1441,11 +2411,13 @@
     }
     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) {
@@ -1459,6 +2431,7 @@
     }
     async function initializeAndActivate(options = {}) {
         const result = await AnsightNative.initializeAndActivate(normalizeOptions(options));
+        await configureNetworkCapture(options.networkCapture);
         if (options.lifecycle !== false)
             startLifecycleTracking();
         if (options.errorCapture) {
@@ -1483,6 +2456,80 @@
         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;
@@ -1538,12 +2585,25 @@
     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)
@@ -1630,7 +2690,7 @@
                 name: "Query JavaScript artifacts",
                 description: "Lists artifacts exposed by Capacitor JavaScript providers.",
                 category: "Artifacts",
-                scope: "read",
+                policy: "read",
             }, async (_args, context) => {
                 const definitions = [];
                 for (const provider of artifactProviders.values()) {
@@ -1661,7 +2721,7 @@
                 name: "Request JavaScript artifact",
                 description: "Creates an artifact through a Capacitor JavaScript provider.",
                 category: "Artifacts",
-                scope: "read",
+                policy: "read",
                 argumentsSchema: {
                     type: "object",
                     required: ["providerId", "artifactId"],
@@ -1894,6 +2954,10 @@
         recordMetric,
         event,
         recordEvent,
+        recordNetworkRequest,
+        installNetworkCapture,
+        uninstallNetworkCapture,
+        sanitizeNetworkRequest,
         screenViewed,
         trackRoute,
         setAppLifecycleState,
@@ -1955,10 +3019,9 @@
         platform: Capacitor.getPlatform(),
     };
 
-    if (typeof window !== "undefined") {
-        const options = Ansight.createOptionsBuilder(globalThis.__ANSIGHT_CAPACITOR_STANDALONE_OPTIONS__ ?? {})
+    function createStandaloneOptions(overrides = {}) {
+        return createOptionsBuilder(overrides)
             .withAnsightDefaults()
-            .withAllToolAccess()
             .withVisualTreeTools()
             .withFileSystemTools()
             .withDatabaseTools()
@@ -1966,7 +3029,12 @@
             .withReflectionTools()
             .withDomTools()
             .withErrorCapture()
+            .withToolGuard(overrides.toolGuard ?? "readOnly")
             .build();
+    }
+
+    if (typeof window !== "undefined") {
+        const options = createStandaloneOptions(globalThis.__ANSIGHT_CAPACITOR_STANDALONE_OPTIONS__ ?? {});
         void Ansight.initializeAndActivate(options).catch((error) => {
             console.error("[Ansight Capacitor]", error);
         });