@ansight/capacitor 1.0.2-preview.6

package/dist/plugin.cjs.js

@@ -0,0 +1,1176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@capacitor/core');
+
+const nodeIds = new WeakMap();
+let nextNodeId = 1;
+function nodeId(element) {
+    const existing = nodeIds.get(element);
+    if (existing)
+        return existing;
+    const id = `dom.${nextNodeId++}`;
+    nodeIds.set(element, id);
+    return id;
+}
+function isVisible(element, style, bounds) {
+    return (style.display !== "none" &&
+        style.visibility !== "hidden" &&
+        style.opacity !== "0" &&
+        bounds.width > 0 &&
+        bounds.height > 0);
+}
+function accessibleLabel(element, includeText) {
+    const labelledBy = element.getAttribute("aria-labelledby");
+    const referenced = labelledBy
+        ?.split(/\s+/)
+        .map((id) => document.getElementById(id)?.textContent?.trim())
+        .filter(Boolean)
+        .join(" ");
+    const label = element.getAttribute("aria-label") ??
+        referenced ??
+        element.getAttribute("alt") ??
+        element.getAttribute("title") ??
+        (includeText
+            ? element.textContent?.replace(/\s+/g, " ").trim().slice(0, 240)
+            : undefined);
+    return label || undefined;
+}
+function attributes(element) {
+    return Object.fromEntries(Array.from(element.attributes, ({ name, value }) => [
+        name,
+        value.slice(0, 500),
+    ]));
+}
+function captureNode(element, options, depth, limits) {
+    if (limits.count >= limits.maxNodes || depth > limits.maxDepth)
+        return null;
+    const style = getComputedStyle(element);
+    const rect = element.getBoundingClientRect();
+    const visible = isVisible(element, style, rect);
+    if (!visible && !options.includeHidden)
+        return null;
+    limits.count += 1;
+    const children = Array.from(element.children)
+        .map((child) => captureNode(child, options, depth + 1, limits))
+        .filter((child) => child !== null);
+    const htmlElement = element;
+    const disabled = element.hasAttribute("disabled") ||
+        element.getAttribute("aria-disabled") === "true";
+    return {
+        id: nodeId(element),
+        type: element.tagName.toLowerCase(),
+        label: accessibleLabel(element, options.includeText),
+        visible,
+        enabled: !disabled,
+        focusable: htmlElement.tabIndex >= 0 ||
+            ["A", "BUTTON", "INPUT", "SELECT", "TEXTAREA", "SUMMARY"].includes(element.tagName),
+        childCount: children.length,
+        bounds: {
+            x: rect.x,
+            y: rect.y,
+            width: rect.width,
+            height: rect.height,
+        },
+        properties: {
+            id: element.id || undefined,
+            role: element.getAttribute("role") ?? undefined,
+            className: element.getAttribute("class") ?? undefined,
+            value: element instanceof HTMLInputElement ||
+                element instanceof HTMLSelectElement ||
+                element instanceof HTMLTextAreaElement
+                ? element.value
+                : undefined,
+            checked: element instanceof HTMLInputElement ? element.checked : undefined,
+            attributes: options.includeAttributes ? attributes(element) : undefined,
+        },
+        children,
+    };
+}
+function findElement(id) {
+    return Array.from(document.querySelectorAll("*")).find((element) => nodeId(element) === id);
+}
+function successful(result, message) {
+    return { success: true, message, result };
+}
+function installDomTools$1(registerTool, input = {}) {
+    const options = {
+        source: input.source ?? "capacitor-dom",
+        includeHidden: input.includeHidden ?? false,
+        maxDepth: input.maxDepth ?? 30,
+        maxNodes: input.maxNodes ?? 1500,
+        includeText: input.includeText ?? true,
+        includeAttributes: input.includeAttributes ?? true,
+        allowActions: input.allowActions ?? false,
+    };
+    const registrations = [
+        registerTool({
+            id: "dom.get_document",
+            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." },
+        }, async () => {
+            const root = document.documentElement;
+            const limits = {
+                maxDepth: options.maxDepth,
+                maxNodes: options.maxNodes,
+                count: 0,
+            };
+            const tree = captureNode(root, options, 0, limits);
+            return successful({
+                platform: "web",
+                source: options.source,
+                adapter: "@ansight/capacitor",
+                capturedAtUtc: new Date().toISOString(),
+                truncated: limits.count >= limits.maxNodes,
+                root: tree,
+            }, "DOM document captured.");
+        }),
+        registerTool({
+            id: "dom.inspect_node",
+            name: "Inspect DOM node",
+            description: "Returns the current state of a DOM node captured by dom.get_document.",
+            category: "UI",
+            scope: "read",
+            argumentsSchema: {
+                type: "object",
+                required: ["nodeId"],
+                properties: { nodeId: { type: "string" } },
+            },
+        }, ({ nodeId: id }) => {
+            const element = findElement(id);
+            if (!element) {
+                return {
+                    success: false,
+                    message: `DOM node '${id}' was not found.`,
+                    errorCode: "dom_node_not_found",
+                };
+            }
+            const limits = { maxDepth: 0, maxNodes: 1, count: 0 };
+            return successful(captureNode(element, options, 0, limits), "DOM node captured.");
+        }),
+        registerTool({
+            id: "dom.query_selector",
+            name: "Query DOM",
+            description: "Finds DOM nodes using a CSS selector.",
+            category: "UI",
+            scope: "read",
+            argumentsSchema: {
+                type: "object",
+                required: ["selector"],
+                properties: { selector: { type: "string" } },
+            },
+        }, ({ selector }) => {
+            try {
+                const matches = Array.from(document.querySelectorAll(selector)).slice(0, 200);
+                return successful(matches.map((element) => ({
+                    id: nodeId(element),
+                    type: element.tagName.toLowerCase(),
+                    label: accessibleLabel(element, true),
+                })), `Matched ${matches.length} DOM node(s).`);
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: error instanceof Error ? error.message : "Invalid CSS selector.",
+                    errorCode: "dom_selector_invalid",
+                };
+            }
+        }),
+    ];
+    if (options.allowActions) {
+        registrations.push(registerTool({
+            id: "dom.invoke_action",
+            name: "Invoke DOM action",
+            description: "Clicks, focuses, blurs, or changes a DOM node.",
+            category: "UI",
+            scope: "write",
+            argumentsSchema: {
+                type: "object",
+                required: ["nodeId", "action"],
+                properties: {
+                    nodeId: { type: "string" },
+                    action: { enum: ["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) {
+                return {
+                    success: false,
+                    message: `DOM node '${id}' was not found.`,
+                    errorCode: "dom_node_not_found",
+                };
+            }
+            if (action === "click")
+                element.click();
+            else if (action === "focus")
+                element.focus();
+            else if (action === "blur")
+                element.blur();
+            else if (action === "setValue" &&
+                (element instanceof HTMLInputElement ||
+                    element instanceof HTMLTextAreaElement ||
+                    element instanceof HTMLSelectElement)) {
+                element.value = value ?? "";
+                element.dispatchEvent(new Event("input", { bubbles: true }));
+                element.dispatchEvent(new Event("change", { bubbles: true }));
+            }
+            else {
+                return {
+                    success: false,
+                    message: `Unsupported action '${action}'.`,
+                    errorCode: "dom_action_unsupported",
+                };
+            }
+            return successful({ nodeId: id, action }, `DOM action '${action}' invoked.`);
+        }));
+    }
+    return {
+        ids: registrations.map(({ id }) => id),
+        ready: Promise.all(registrations.map(({ ready }) => ready)),
+        unregister: () => Promise.all(registrations.map((registration) => registration.unregister())),
+    };
+}
+
+function cloneOptions(options) {
+    return JSON.parse(JSON.stringify(options));
+}
+class AnsightOptionsBuilder {
+    options;
+    constructor(options = {}) {
+        this.options = cloneOptions(options);
+    }
+    withAnsightDefaults() {
+        this.options = {
+            ...this.options,
+            useNativeAllInOneDefaults: true,
+            sampleFrequencyMilliseconds: 400,
+            retentionPeriodSeconds: 120,
+            enableFramesPerSecond: true,
+            enableBatteryLevel: false,
+            sessionJpegCapture: {
+                intervalMilliseconds: 2000,
+                quality: 60,
+                maxWidth: 480,
+            },
+            touchCapture: {},
+            toolGuard: "readOnly",
+            hostAutoProbe: {
+                ...this.options.hostAutoProbe,
+                enabled: true,
+            },
+        };
+        return this;
+    }
+    withNativeAllInOneDefaults() {
+        return this.withAnsightDefaults();
+    }
+    withAnsightSdk(configure) {
+        this.withAnsightDefaults().withAllToolAccess();
+        configure?.(this);
+        return this;
+    }
+    withSampleFrequencyMilliseconds(value) {
+        this.options.sampleFrequencyMilliseconds = value;
+        return this;
+    }
+    withFramesPerSecond() {
+        this.options.enableFramesPerSecond = true;
+        return this;
+    }
+    withoutFramesPerSecond() {
+        this.options.enableFramesPerSecond = false;
+        return this;
+    }
+    withBatteryLevel() {
+        this.options.enableBatteryLevel = true;
+        return this;
+    }
+    withoutBatteryLevel() {
+        this.options.enableBatteryLevel = false;
+        return this;
+    }
+    withRetentionPeriodSeconds(value) {
+        this.options.retentionPeriodSeconds = value;
+        return this;
+    }
+    withAdditionalChannels(channels) {
+        this.options.additionalChannels = channels.map((channel) => ({
+            ...channel,
+        }));
+        return this;
+    }
+    addAdditionalChannel(channel) {
+        this.options.additionalChannels = [
+            ...(this.options.additionalChannels ?? []),
+            { ...channel },
+        ];
+        return this;
+    }
+    withDefaultMemoryChannels(channels) {
+        this.options.defaultMemoryChannels = { ...channels };
+        return this;
+    }
+    withoutDefaultMemoryChannels(channels) {
+        const current = {
+            managedHeap: true,
+            javaHeap: true,
+            nativeHeap: true,
+            residentSetSize: true,
+            rss: true,
+            physicalFootprint: true,
+            ...this.options.defaultMemoryChannels,
+        };
+        for (const [key, disabled] of Object.entries(channels)) {
+            if (disabled)
+                current[key] = false;
+        }
+        this.options.defaultMemoryChannels = current;
+        return this;
+    }
+    withSessionJpegCapture(optionsOrIntervalMilliseconds = {}, quality = 60, maxWidth = 480, captureGpuBackedSurfaces = true) {
+        this.options.sessionJpegCapture =
+            typeof optionsOrIntervalMilliseconds === "number"
+                ? {
+                    intervalMilliseconds: optionsOrIntervalMilliseconds,
+                    quality,
+                    maxWidth,
+                    captureGpuBackedSurfaces,
+                }
+                : {
+                    intervalMilliseconds: 2000,
+                    quality: 60,
+                    maxWidth: 480,
+                    ...optionsOrIntervalMilliseconds,
+                };
+        return this;
+    }
+    withoutSessionJpegCapture() {
+        this.options.sessionJpegCapture = false;
+        return this;
+    }
+    withTouchCapture(options = {}) {
+        this.options.touchCapture = { ...options };
+        return this;
+    }
+    withoutTouchCapture() {
+        this.options.touchCapture = false;
+        return this;
+    }
+    withLifecycleCapture(options = {}) {
+        this.options.lifecycleCapture = {
+            ...options,
+            enabled: options.enabled ?? true,
+        };
+        return this;
+    }
+    withToolGuard(toolGuard) {
+        this.options.toolGuard = toolGuard;
+        return this;
+    }
+    withToolsDisabled() {
+        return this.withToolGuard("disabled");
+    }
+    withReadOnlyToolAccess() {
+        return this.withToolGuard("readOnly");
+    }
+    withReadWriteToolAccess() {
+        return this.withToolGuard("readWrite");
+    }
+    withAllToolAccess() {
+        return this.withToolGuard("fullAccess");
+    }
+    withHostAutoProbe(options = {}) {
+        this.options.hostAutoProbe = {
+            ...options,
+            enabled: options.enabled ?? true,
+        };
+        return this;
+    }
+    withoutHostAutoProbe() {
+        this.options.hostAutoProbe = {
+            ...this.options.hostAutoProbe,
+            enabled: false,
+        };
+        return this;
+    }
+    withHostConnection(options = {}) {
+        this.options.hostConnection = { ...options };
+        return this;
+    }
+    configureHostConnection(configure) {
+        const current = { ...this.options.hostConnection };
+        this.options.hostConnection = configure(current) ?? current;
+        return this;
+    }
+    withBundledHostConnection(options = {}) {
+        return this.configureHostConnection((current) => ({
+            ...current,
+            bundledDeveloperConfigJson: options.bundledDeveloperConfigJson,
+            bundledConfigJson: options.bundledConfigJson,
+        }));
+    }
+    withHostConnectionDiscoveryPort(discoveryPort) {
+        return this.configureHostConnection((current) => ({
+            ...current,
+            discoveryPort,
+        }));
+    }
+    withHostConnectionProfileRetentionSeconds(connectionProfileRetentionSeconds) {
+        return this.configureHostConnection((current) => ({
+            ...current,
+            connectionProfileRetentionSeconds,
+        }));
+    }
+    withSecureStorage(options = {}) {
+        this.options.secureStorage = {
+            ...options,
+            allowedKeys: options.allowedKeys ? [...options.allowedKeys] : undefined,
+            allowedPrefixes: options.allowedPrefixes
+                ? [...options.allowedPrefixes]
+                : undefined,
+        };
+        return this;
+    }
+    withRemoteTools(options = {}) {
+        this.options.remoteTools = cloneOptions({
+            remoteTools: options,
+        }).remoteTools;
+        return this;
+    }
+    withVisualTreeTools(options = {}) {
+        this.options.remoteTools = {
+            ...this.options.remoteTools,
+            visualTree: typeof options === "boolean"
+                ? options
+                : { ...options, enabled: options.enabled ?? true },
+        };
+        return this;
+    }
+    withoutVisualTreeTools() {
+        this.options.remoteTools = {
+            ...this.options.remoteTools,
+            visualTree: false,
+        };
+        return this;
+    }
+    withFileSystemTools(options = {}) {
+        this.options.remoteTools = {
+            ...this.options.remoteTools,
+            fileSystem: cloneOptions({ remoteTools: { fileSystem: options } })
+                .remoteTools?.fileSystem,
+        };
+        return this;
+    }
+    withDatabaseTools(options = {}) {
+        this.options.remoteTools = {
+            ...this.options.remoteTools,
+            database: cloneOptions({ remoteTools: { database: options } }).remoteTools
+                ?.database,
+        };
+        return this;
+    }
+    withPreferencesTools(options = {}) {
+        this.options.remoteTools = {
+            ...this.options.remoteTools,
+            preferences: cloneOptions({ remoteTools: { preferences: options } })
+                .remoteTools?.preferences,
+        };
+        return this;
+    }
+    withReflectionTools(options = {}) {
+        this.options.remoteTools = {
+            ...this.options.remoteTools,
+            reflection: cloneOptions({ remoteTools: { reflection: options } })
+                .remoteTools?.reflection,
+        };
+        return this;
+    }
+    withDomTools(options = {}) {
+        this.options.domTools = { ...options };
+        return this;
+    }
+    withErrorCapture(options = {}) {
+        this.options.errorCapture = { ...options };
+        return this;
+    }
+    registerCustomProperty(group, key, value) {
+        this.options.customProperties = {
+            ...this.options.customProperties,
+            [group]: {
+                ...this.options.customProperties?.[group],
+                [key]: String(value),
+            },
+        };
+        return this;
+    }
+    removeCustomProperty(group, key) {
+        const groups = cloneOptions({ customProperties: this.options.customProperties })
+            .customProperties ?? {};
+        delete groups[group]?.[key];
+        if (groups[group] && Object.keys(groups[group]).length === 0) {
+            delete groups[group];
+        }
+        this.options.customProperties = groups;
+        return this;
+    }
+    clearCustomProperties() {
+        this.options.customProperties = {};
+        return this;
+    }
+    build() {
+        return cloneOptions(this.options);
+    }
+}
+function createOptionsBuilder(options = {}) {
+    return new AnsightOptionsBuilder(options);
+}
+
+const AnsightNative = core.registerPlugin("Ansight");
+const toolHandlers = new Map();
+const artifactProviders = new Map();
+const hostConnectionListeners = new Set();
+const logListeners = new Set();
+let toolListener;
+let logListener;
+let lifecycleCleanup;
+let artifactToolRegistrations = [];
+let domToolRegistration;
+function normalizePairingPayload(payload) {
+    if (payload == null)
+        return payload;
+    return typeof payload === "string" ? payload : JSON.stringify(payload);
+}
+function normalizeOptions(input) {
+    const options = JSON.parse(JSON.stringify(input));
+    if (options.pairingConfig != null) {
+        options.pairingConfigJson =
+            normalizePairingPayload(options.pairingConfig) ?? undefined;
+        delete options.pairingConfig;
+    }
+    if (options.bundledPairingConfig != null) {
+        options.pairingConfigJson =
+            normalizePairingPayload(options.bundledPairingConfig) ?? undefined;
+        delete options.bundledPairingConfig;
+    }
+    delete options.domTools;
+    delete options.errorCapture;
+    delete options.lifecycle;
+    return options;
+}
+function normalizeToolResult(value) {
+    if (value && typeof value === "object" && "success" in value) {
+        return value;
+    }
+    return { success: true, result: value };
+}
+function errorToolResult(error) {
+    return {
+        success: false,
+        message: error instanceof Error ? error.message : String(error),
+        errorCode: "javascript_tool_failed",
+    };
+}
+async function ensureToolListener() {
+    toolListener ??= AnsightNative.addListener("ansightToolCall", (call) => {
+        const handler = toolHandlers.get(call.toolId);
+        void Promise.resolve(handler
+            ? handler(call.arguments ?? {}, call)
+            : {
+                success: false,
+                message: `No JavaScript handler is registered for '${call.toolId}'.`,
+                errorCode: "javascript_tool_not_registered",
+            })
+            .then(normalizeToolResult)
+            .catch(errorToolResult)
+            .then((result) => AnsightNative.resolveToolCall({ requestId: call.requestId, result }))
+            .catch(() => undefined);
+    });
+    return toolListener;
+}
+async function ensureLogListener() {
+    logListener ??= AnsightNative.addListener("ansightLog", (entry) => {
+        for (const listener of logListeners)
+            listener(entry);
+    });
+    return logListener;
+}
+async function emitHostConnectionStatus() {
+    if (hostConnectionListeners.size === 0)
+        return;
+    const [status, capabilities] = await Promise.all([
+        AnsightNative.hostConnectionStatus(),
+        AnsightNative.hostConnectionCapabilities(),
+    ]);
+    for (const listener of hostConnectionListeners)
+        listener(status, capabilities);
+}
+async function afterConnectionChange(operation) {
+    const result = await operation();
+    await emitHostConnectionStatus();
+    return result;
+}
+async function initialize(options = {}) {
+    const result = await AnsightNative.initialize(normalizeOptions(options));
+    if (options.lifecycle !== false)
+        startLifecycleTracking();
+    if (options.errorCapture) {
+        installErrorHandlers(typeof options.errorCapture === "object" ? options.errorCapture : {});
+    }
+    if (options.domTools) {
+        installDomTools(typeof options.domTools === "object" ? options.domTools : {});
+    }
+    await emitHostConnectionStatus();
+    return result;
+}
+async function initializeAndActivate(options = {}) {
+    const result = await AnsightNative.initializeAndActivate(normalizeOptions(options));
+    if (options.lifecycle !== false)
+        startLifecycleTracking();
+    if (options.errorCapture) {
+        installErrorHandlers(typeof options.errorCapture === "object" ? options.errorCapture : {});
+    }
+    if (options.domTools) {
+        installDomTools(typeof options.domTools === "object" ? options.domTools : {});
+    }
+    await emitHostConnectionStatus();
+    return result;
+}
+const activate = () => afterConnectionChange(() => AnsightNative.activate());
+async function deactivate() {
+    stopLifecycleTracking();
+    return afterConnectionChange(() => AnsightNative.deactivate());
+}
+const clear = () => afterConnectionChange(() => AnsightNative.clear());
+const registerMetricChannel = (channel) => AnsightNative.registerMetricChannel({ channel });
+const metric = (value, channel = 255) => AnsightNative.recordMetric({ value, channel });
+const recordMetric = metric;
+function event(input) {
+    return AnsightNative.recordEvent(typeof input === "string" ? { label: input } : input);
+}
+const recordEvent = event;
+const screenViewed = (name, details = {}) => AnsightNative.screenViewed({ name, details });
+const trackRoute = screenViewed;
+const setAppLifecycleState = (state) => AnsightNative.setAppLifecycleState({ state });
+function connect(pairingPayload, options = {}) {
+    return afterConnectionChange(() => AnsightNative.connect({
+        ...options,
+        pairingPayload: normalizePairingPayload(pairingPayload),
+    }));
+}
+function scanPairingQrCode(options = {}) {
+    return afterConnectionChange(() => AnsightNative.scanPairingQrCode(options));
+}
+function openSession(pairingPayload, options = {}) {
+    return afterConnectionChange(() => AnsightNative.openSession({
+        ...options,
+        pairingPayload: normalizePairingPayload(pairingPayload) ?? "",
+    }));
+}
+const disconnect = () => afterConnectionChange(() => AnsightNative.disconnect());
+const completeSession = () => afterConnectionChange(() => AnsightNative.completeSession());
+const closeSession = () => afterConnectionChange(() => AnsightNative.closeSession());
+const savePairingConfig = (pairingPayload, options = {}) => afterConnectionChange(() => AnsightNative.savePairingConfig({
+    ...options,
+    pairingPayload: normalizePairingPayload(pairingPayload) ?? "",
+}));
+const clearSavedPairing = () => afterConnectionChange(() => AnsightNative.clearSavedPairing());
+const clearSavedPairingConfig = clearSavedPairing;
+const clearCachedSession = () => afterConnectionChange(() => AnsightNative.clearCachedSession());
+const notifyHostConnectionConfigChanged = () => afterConnectionChange(() => AnsightNative.notifyHostConnectionConfigChanged());
+const status = () => AnsightNative.status();
+const snapshot = () => AnsightNative.snapshot();
+const hostConnectionStatus = () => AnsightNative.hostConnectionStatus();
+const hostConnectionCapabilities = () => AnsightNative.hostConnectionCapabilities();
+const currentOptions = () => AnsightNative.currentOptions();
+async function recordedMetrics(limit = 0) {
+    return (await AnsightNative.recordedMetrics({ limit })).items;
+}
+async function recordedEvents(limit = 0) {
+    return (await AnsightNative.recordedEvents({ limit })).items;
+}
+const sendClientLog = (line) => AnsightNative.sendClientLog({ line });
+const captureBuiltInTelemetrySample = () => AnsightNative.captureBuiltInTelemetrySample();
+async function isFramesPerSecondEnabled() {
+    return (await AnsightNative.isFramesPerSecondEnabled()).value;
+}
+const enableFramesPerSecond = () => AnsightNative.enableFramesPerSecond();
+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 updateCustomProperties = updateSessionProperties;
+const clearSessionProperties = () => AnsightNative.clearSessionProperties();
+const clearCustomProperties = clearSessionProperties;
+const registerCustomProperty = (group, key, value) => AnsightNative.registerCustomProperty({ group, key, value });
+const removeCustomProperty = (group, key) => AnsightNative.removeCustomProperty({ group, key });
+function addHostConnectionStatusListener(listener, options = {}) {
+    hostConnectionListeners.add(listener);
+    if (options.emitCurrent !== false)
+        void emitHostConnectionStatus();
+    return {
+        remove: () => {
+            hostConnectionListeners.delete(listener);
+        },
+    };
+}
+function addLogListener(listener) {
+    logListeners.add(listener);
+    void ensureLogListener();
+    return {
+        remove: () => {
+            logListeners.delete(listener);
+        },
+    };
+}
+function registerTool(definition, handler) {
+    if (!definition?.id?.trim())
+        throw new TypeError("registerTool requires a stable string id.");
+    if (typeof handler !== "function")
+        throw new TypeError("registerTool requires a handler function.");
+    toolHandlers.set(definition.id, handler);
+    const ready = ensureToolListener()
+        .then(() => AnsightNative.registerCustomTool({ definition }))
+        .catch((error) => {
+        toolHandlers.delete(definition.id);
+        throw error;
+    });
+    return {
+        id: definition.id,
+        ready,
+        unregister: async () => {
+            toolHandlers.delete(definition.id);
+            return AnsightNative.unregisterCustomTool({ id: definition.id });
+        },
+    };
+}
+function unregisterTool(id) {
+    toolHandlers.delete(id);
+    return AnsightNative.unregisterCustomTool({ id });
+}
+const listRegisteredTools = () => [...toolHandlers.keys()];
+async function clearRegisteredTools() {
+    toolHandlers.clear();
+    artifactProviders.clear();
+    artifactToolRegistrations = [];
+    domToolRegistration = undefined;
+    return AnsightNative.clearRegisteredCustomTools();
+}
+function bytesToBase64(bytes) {
+    let binary = "";
+    for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+    }
+    return btoa(binary);
+}
+function payloadBytes(payload) {
+    if (payload instanceof Uint8Array)
+        return payload;
+    if (payload instanceof ArrayBuffer)
+        return new Uint8Array(payload);
+    if (Array.isArray(payload))
+        return Uint8Array.from(payload);
+    if (typeof payload === "object" && payload) {
+        const candidate = payload.bytes ?? payload.data;
+        if (candidate instanceof Uint8Array)
+            return candidate;
+        if (candidate instanceof ArrayBuffer)
+            return new Uint8Array(candidate);
+        if (Array.isArray(candidate))
+            return Uint8Array.from(candidate);
+    }
+    return undefined;
+}
+function installArtifactTools() {
+    if (artifactToolRegistrations.length > 0)
+        return artifactToolRegistrations;
+    artifactToolRegistrations = [
+        registerTool({
+            id: "artifacts.query",
+            name: "Query JavaScript artifacts",
+            description: "Lists artifacts exposed by Capacitor JavaScript providers.",
+            category: "Artifacts",
+            scope: "read",
+        }, async (_args, context) => {
+            const definitions = [];
+            for (const provider of artifactProviders.values()) {
+                const query = provider.queryArtifacts ?? provider.query;
+                const artifacts = query
+                    ? await query({
+                        toolRequestId: context.nativeRequestId ?? context.requestId,
+                        sessionId: context.sessionId,
+                        queriedAtUtc: new Date().toISOString(),
+                    })
+                    : [];
+                definitions.push(...artifacts.map((artifact) => ({
+                    ...artifact,
+                    providerId: provider.descriptor.id,
+                })));
+            }
+            return {
+                success: true,
+                message: `Found ${definitions.length} artifact(s).`,
+                result: {
+                    providers: [...artifactProviders.values()].map(({ descriptor }) => descriptor),
+                    artifacts: definitions,
+                },
+            };
+        }),
+        registerTool({
+            id: "artifacts.request",
+            name: "Request JavaScript artifact",
+            description: "Creates an artifact through a Capacitor JavaScript provider.",
+            category: "Artifacts",
+            scope: "read",
+            argumentsSchema: {
+                type: "object",
+                required: ["providerId", "artifactId"],
+                properties: {
+                    providerId: { type: "string" },
+                    artifactId: { type: "string" },
+                },
+            },
+        }, async (args, context) => {
+            const provider = artifactProviders.get(args.providerId);
+            const create = provider && (provider.createArtifact ?? provider.create);
+            if (!provider || !create) {
+                return {
+                    success: false,
+                    message: `Artifact provider '${args.providerId}' is unavailable.`,
+                    errorCode: "artifact_provider_not_found",
+                };
+            }
+            const result = await create({
+                providerId: args.providerId,
+                artifactId: args.artifactId,
+                arguments: args,
+                context: {
+                    toolRequestId: context.nativeRequestId ?? context.requestId,
+                    sessionId: context.sessionId,
+                    requestedAtUtc: new Date().toISOString(),
+                },
+            });
+            const bytes = payloadBytes(result.payload);
+            if (bytes) {
+                const transfer = await AnsightNative.queueBinaryTransfer({
+                    requestId: context.nativeRequestId ?? context.requestId,
+                    base64Data: bytesToBase64(bytes),
+                    chunkBytes: 64 * 1024,
+                });
+                return {
+                    success: transfer.success,
+                    message: transfer.message,
+                    result: { metadata: result.metadata, transfer },
+                    ...(!transfer.success && {
+                        errorCode: "artifact_transfer_unavailable",
+                    }),
+                };
+            }
+            const payload = typeof result.payload === "object" &&
+                result.payload &&
+                "text" in result.payload
+                ? result.payload.text
+                : result.payload;
+            return {
+                success: true,
+                message: `Artifact '${args.artifactId}' created.`,
+                result: { metadata: result.metadata, payload },
+            };
+        }),
+    ];
+    return artifactToolRegistrations;
+}
+function registerArtifactProvider(provider) {
+    const id = provider?.descriptor?.id?.trim();
+    if (!id)
+        throw new TypeError("registerArtifactProvider requires descriptor.id.");
+    artifactProviders.set(id, provider);
+    const registrations = installArtifactTools();
+    return {
+        id,
+        ready: Promise.all(registrations.map(({ ready }) => ready)).then(() => ({
+            success: true,
+            message: `Artifact provider '${id}' registered.`,
+        })),
+        unregister: () => unregisterArtifactProvider(id),
+    };
+}
+const registerArtifactProviders = (providers) => providers.map(registerArtifactProvider);
+async function unregisterArtifactProvider(id) {
+    artifactProviders.delete(id);
+    if (artifactProviders.size === 0) {
+        const registrations = artifactToolRegistrations;
+        artifactToolRegistrations = [];
+        await Promise.all(registrations.map(({ unregister }) => unregister()));
+    }
+    return { success: true, message: `Artifact provider '${id}' unregistered.` };
+}
+const listRegisteredArtifactProviders = () => [...artifactProviders.values()].map(({ descriptor }) => descriptor);
+async function clearArtifactProviders() {
+    artifactProviders.clear();
+    const registrations = artifactToolRegistrations;
+    artifactToolRegistrations = [];
+    await Promise.all(registrations.map(({ unregister }) => unregister()));
+    return { success: true, message: "JavaScript artifact providers cleared." };
+}
+function installDomTools(options = {}) {
+    domToolRegistration ??= installDomTools$1(registerTool, options);
+    return domToolRegistration;
+}
+async function uninstallDomTools() {
+    const registration = domToolRegistration;
+    domToolRegistration = undefined;
+    return registration ? registration.unregister() : [];
+}
+function startLifecycleTracking() {
+    if (lifecycleCleanup || typeof document === "undefined")
+        return;
+    const update = () => void setAppLifecycleState(document.visibilityState === "visible" ? "foreground" : "background");
+    document.addEventListener("visibilitychange", update);
+    window.addEventListener("pageshow", update);
+    window.addEventListener("pagehide", update);
+    lifecycleCleanup = () => {
+        document.removeEventListener("visibilitychange", update);
+        window.removeEventListener("pageshow", update);
+        window.removeEventListener("pagehide", update);
+    };
+    update();
+}
+function stopLifecycleTracking() {
+    lifecycleCleanup?.();
+    lifecycleCleanup = undefined;
+}
+const startAppStateTracking = startLifecycleTracking;
+const stopAppStateTracking = stopLifecycleTracking;
+function installErrorHandlers(options = {}) {
+    const captureErrors = options.errors ?? true;
+    const captureRejections = options.unhandledRejections ?? true;
+    const captureConsole = options.consoleErrors ?? false;
+    const onError = (eventValue) => {
+        if (!captureErrors)
+            return;
+        void event({
+            label: eventValue.message || "Unhandled JavaScript error",
+            type: "Exception",
+            details: JSON.stringify({
+                filename: eventValue.filename,
+                line: eventValue.lineno,
+                column: eventValue.colno,
+                stack: eventValue.error instanceof Error
+                    ? eventValue.error.stack
+                    : undefined,
+            }),
+        }).catch(() => undefined);
+    };
+    const onRejection = (eventValue) => {
+        if (!captureRejections)
+            return;
+        const reason = eventValue.reason;
+        void event({
+            label: reason instanceof Error
+                ? reason.message
+                : "Unhandled JavaScript rejection",
+            type: "Exception",
+            details: JSON.stringify({
+                reason: reason instanceof Error ? reason.stack : String(reason),
+            }),
+        }).catch(() => undefined);
+    };
+    window.addEventListener("error", onError);
+    window.addEventListener("unhandledrejection", onRejection);
+    const originalConsoleError = console.error;
+    if (captureConsole) {
+        console.error = (...args) => {
+            originalConsoleError(...args);
+            void event({
+                label: "console.error",
+                type: "Exception",
+                details: args.map(String).join(" "),
+            }).catch(() => undefined);
+        };
+    }
+    return () => {
+        window.removeEventListener("error", onError);
+        window.removeEventListener("unhandledrejection", onRejection);
+        if (captureConsole)
+            console.error = originalConsoleError;
+    };
+}
+function createRouteTracker(options = {}) {
+    const resolveName = options.resolveName ?? ((url) => url.pathname + url.search + url.hash);
+    const record = () => void screenViewed(resolveName(new URL(location.href)), options.details);
+    const originalPushState = history.pushState.bind(history);
+    const originalReplaceState = history.replaceState.bind(history);
+    const onPopState = () => record();
+    window.addEventListener("popstate", onPopState);
+    window.addEventListener("hashchange", onPopState);
+    if (options.observeHistory !== false) {
+        history.pushState = (...args) => {
+            originalPushState(...args);
+            record();
+        };
+        history.replaceState = (...args) => {
+            originalReplaceState(...args);
+            record();
+        };
+    }
+    record();
+    return {
+        remove: () => {
+            window.removeEventListener("popstate", onPopState);
+            window.removeEventListener("hashchange", onPopState);
+            history.pushState = originalPushState;
+            history.replaceState = originalReplaceState;
+        },
+    };
+}
+const Ansight = {
+    initialize,
+    initializeAndActivate,
+    activate,
+    deactivate,
+    clear,
+    registerMetricChannel,
+    metric,
+    recordMetric,
+    event,
+    recordEvent,
+    screenViewed,
+    trackRoute,
+    setAppLifecycleState,
+    connect,
+    scanPairingQrCode,
+    openSession,
+    disconnect,
+    completeSession,
+    closeSession,
+    savePairingConfig,
+    clearSavedPairing,
+    clearSavedPairingConfig,
+    clearCachedSession,
+    notifyHostConnectionConfigChanged,
+    status,
+    snapshot,
+    hostConnectionStatus,
+    hostConnectionCapabilities,
+    addHostConnectionStatusListener,
+    currentOptions,
+    recordedMetrics,
+    recordedEvents,
+    sendClientLog,
+    addLogListener,
+    captureBuiltInTelemetrySample,
+    isFramesPerSecondEnabled,
+    enableFramesPerSecond,
+    disableFramesPerSecond,
+    captureScreenFrame,
+    enableTouchCapture,
+    disableTouchCapture,
+    updateSessionProperties,
+    updateCustomProperties,
+    clearSessionProperties,
+    registerCustomProperty,
+    removeCustomProperty,
+    clearCustomProperties,
+    registerTool,
+    unregisterTool,
+    listRegisteredTools,
+    clearRegisteredTools,
+    registerArtifactProvider,
+    registerArtifactProviders,
+    unregisterArtifactProvider,
+    listRegisteredArtifactProviders,
+    clearArtifactProviders,
+    installDomTools,
+    uninstallDomTools,
+    installErrorHandlers,
+    createRouteTracker,
+    startLifecycleTracking,
+    stopLifecycleTracking,
+    startAppStateTracking,
+    stopAppStateTracking,
+    createOptionsBuilder,
+    AnsightOptionsBuilder,
+    native: AnsightNative,
+    platform: core.Capacitor.getPlatform(),
+};
+
+exports.AnsightNative = AnsightNative;
+exports.AnsightOptionsBuilder = AnsightOptionsBuilder;
+exports.activate = activate;
+exports.addHostConnectionStatusListener = addHostConnectionStatusListener;
+exports.addLogListener = addLogListener;
+exports.captureBuiltInTelemetrySample = captureBuiltInTelemetrySample;
+exports.captureScreenFrame = captureScreenFrame;
+exports.clear = clear;
+exports.clearArtifactProviders = clearArtifactProviders;
+exports.clearCachedSession = clearCachedSession;
+exports.clearCustomProperties = clearCustomProperties;
+exports.clearRegisteredTools = clearRegisteredTools;
+exports.clearSavedPairing = clearSavedPairing;
+exports.clearSavedPairingConfig = clearSavedPairingConfig;
+exports.clearSessionProperties = clearSessionProperties;
+exports.closeSession = closeSession;
+exports.completeSession = completeSession;
+exports.connect = connect;
+exports.createOptionsBuilder = createOptionsBuilder;
+exports.createRouteTracker = createRouteTracker;
+exports.currentOptions = currentOptions;
+exports.deactivate = deactivate;
+exports.default = Ansight;
+exports.disableFramesPerSecond = disableFramesPerSecond;
+exports.disableTouchCapture = disableTouchCapture;
+exports.disconnect = disconnect;
+exports.enableFramesPerSecond = enableFramesPerSecond;
+exports.enableTouchCapture = enableTouchCapture;
+exports.event = event;
+exports.hostConnectionCapabilities = hostConnectionCapabilities;
+exports.hostConnectionStatus = hostConnectionStatus;
+exports.initialize = initialize;
+exports.initializeAndActivate = initializeAndActivate;
+exports.installDomTools = installDomTools;
+exports.installErrorHandlers = installErrorHandlers;
+exports.isFramesPerSecondEnabled = isFramesPerSecondEnabled;
+exports.listRegisteredArtifactProviders = listRegisteredArtifactProviders;
+exports.listRegisteredTools = listRegisteredTools;
+exports.metric = metric;
+exports.notifyHostConnectionConfigChanged = notifyHostConnectionConfigChanged;
+exports.openSession = openSession;
+exports.recordEvent = recordEvent;
+exports.recordMetric = recordMetric;
+exports.recordedEvents = recordedEvents;
+exports.recordedMetrics = recordedMetrics;
+exports.registerArtifactProvider = registerArtifactProvider;
+exports.registerArtifactProviders = registerArtifactProviders;
+exports.registerCustomProperty = registerCustomProperty;
+exports.registerMetricChannel = registerMetricChannel;
+exports.registerTool = registerTool;
+exports.removeCustomProperty = removeCustomProperty;
+exports.savePairingConfig = savePairingConfig;
+exports.scanPairingQrCode = scanPairingQrCode;
+exports.screenViewed = screenViewed;
+exports.sendClientLog = sendClientLog;
+exports.setAppLifecycleState = setAppLifecycleState;
+exports.snapshot = snapshot;
+exports.startAppStateTracking = startAppStateTracking;
+exports.startLifecycleTracking = startLifecycleTracking;
+exports.status = status;
+exports.stopAppStateTracking = stopAppStateTracking;
+exports.stopLifecycleTracking = stopLifecycleTracking;
+exports.trackRoute = trackRoute;
+exports.uninstallDomTools = uninstallDomTools;
+exports.unregisterArtifactProvider = unregisterArtifactProvider;
+exports.unregisterTool = unregisterTool;
+exports.updateCustomProperties = updateCustomProperties;
+exports.updateSessionProperties = updateSessionProperties;
+//# sourceMappingURL=plugin.cjs.js.map