capdebug 0.1.0 → 0.3.0

package/dist/plugin.js

@@ -1,846 +1,776 @@
 var capacitorCapDebug = (function (exports, core) {
-    'use strict';
-
-    const DEFAULT_SENSITIVE_KEYS = new Set([
-        'authorization',
-        'cookie',
-        'set-cookie',
-        'password',
-        'passwd',
-        'pass',
-        'token',
-        'access_token',
-        'accesstoken',
-        'refresh_token',
-        'refreshtoken',
-        'api_key',
-        'apikey',
-        'secret',
-        'client_secret',
-        'clientsecret',
-        'bearer',
-        'private_key',
-        'privatekey',
-        'session_id',
-        'sessionid',
-        'jwt',
-        'credit_card',
-        'creditcard',
-        'cvv',
-        'ssn',
-    ]);
-    const MASK_VALUE = '********';
-    class DataSanitizer {
-        maskKeys;
-        maxDepth;
-        maxArrayLength;
-        constructor(options = {}) {
-            this.maskKeys = new Set([
-                ...DEFAULT_SENSITIVE_KEYS,
-                ...(options.customMaskKeys || []).map(k => k.toLowerCase().trim()),
-            ]);
-            this.maxDepth = options.maxDepth ?? 10;
-            this.maxArrayLength = options.maxArrayLength ?? 100;
-        }
-        isSensitiveKey(key) {
-            const normalized = key.toLowerCase().replace(/[-_]/g, '');
-            if (this.maskKeys.has(key.toLowerCase()) || this.maskKeys.has(normalized)) {
-                return true;
-            }
-            for (const sensitive of this.maskKeys) {
-                const cleanSensitive = sensitive.replace(/[-_]/g, '');
-                if (normalized.includes(cleanSensitive) && cleanSensitive.length >= 4) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        sanitize(value) {
-            const seen = new WeakSet();
-            return this.sanitizeRecursive(value, 0, seen);
-        }
-        sanitizeRecursive(value, depth, seen) {
-            if (value === null || value === undefined) {
-                return value;
-            }
-            if (depth > this.maxDepth) {
-                return '[Max Depth Reached]';
-            }
-            const type = typeof value;
-            if (type === 'string' || type === 'number' || type === 'boolean') {
-                return value;
-            }
-            if (type === 'bigint') {
-                return value.toString() + 'n';
-            }
-            if (type === 'symbol') {
-                return value.toString();
-            }
-            if (type === 'function') {
-                return `[Function: ${value.name || 'anonymous'}]`;
-            }
-            if (typeof value === 'object') {
-                // Check circular reference
-                if (seen.has(value)) {
-                    return '[Circular Reference]';
-                }
-                seen.add(value);
-                // Error handling
-                if (value instanceof Error) {
-                    return {
-                        name: value.name,
-                        message: value.message,
-                        stack: value.stack,
-                        ...value,
-                    };
-                }
-                // Date handling
-                if (value instanceof Date) {
-                    return value.toISOString();
-                }
-                // RegExp handling
-                if (value instanceof RegExp) {
-                    return value.toString();
-                }
-                // DOM Node handling
-                if (typeof Element !== 'undefined' && value instanceof Element) {
-                    const id = value.id ? `#${value.id}` : '';
-                    const className = value.className ? `.${String(value.className).trim().replace(/\s+/g, '.')}` : '';
-                    return `<${value.tagName.toLowerCase()}${id}${className}>`;
-                }
-                // Array handling
-                if (Array.isArray(value)) {
-                    const arr = value.slice(0, this.maxArrayLength).map(item => this.sanitizeRecursive(item, depth + 1, seen));
-                    if (value.length > this.maxArrayLength) {
-                        arr.push(`[... ${value.length - this.maxArrayLength} more items]`);
-                    }
-                    return arr;
-                }
-                // Map handling
-                if (value instanceof Map) {
-                    const entries = {};
-                    for (const [k, v] of value.entries()) {
-                        const keyStr = String(k);
-                        entries[keyStr] = this.isSensitiveKey(keyStr)
-                            ? MASK_VALUE
-                            : this.sanitizeRecursive(v, depth + 1, seen);
-                    }
-                    return entries;
-                }
-                // Set handling
-                if (value instanceof Set) {
-                    return Array.from(value).map(item => this.sanitizeRecursive(item, depth + 1, seen));
-                }
-                // Plain Object handling
-                const result = {};
-                const obj = value;
-                for (const [key, val] of Object.entries(obj)) {
-                    if (this.isSensitiveKey(key)) {
-                        result[key] = MASK_VALUE;
-                    }
-                    else {
-                        result[key] = this.sanitizeRecursive(val, depth + 1, seen);
-                    }
-                }
-                return result;
+  'use strict';
+
+  const DEFAULT_SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "password",
+    "passwd",
+    "pass",
+    "token",
+    "access_token",
+    "accesstoken",
+    "refresh_token",
+    "refreshtoken",
+    "api_key",
+    "apikey",
+    "secret",
+    "client_secret",
+    "clientsecret",
+    "bearer",
+    "private_key",
+    "privatekey",
+    "session_id",
+    "sessionid",
+    "jwt",
+    "credit_card",
+    "creditcard",
+    "cvv",
+    "ssn"
+  ]);
+  const MASK_VALUE = "********";
+  class DataSanitizer {
+    maskKeys;
+    maxDepth;
+    maxArrayLength;
+    constructor(options = {}) {
+      this.maskKeys = /* @__PURE__ */ new Set([
+        ...DEFAULT_SENSITIVE_KEYS,
+        ...(options.customMaskKeys || []).map((k) => k.toLowerCase().trim())
+      ]);
+      this.maxDepth = options.maxDepth ?? 10;
+      this.maxArrayLength = options.maxArrayLength ?? 100;
+    }
+    isSensitiveKey(key) {
+      const normalized = key.toLowerCase().replace(/[-_]/g, "");
+      if (this.maskKeys.has(key.toLowerCase()) || this.maskKeys.has(normalized)) {
+        return true;
+      }
+      for (const sensitive of this.maskKeys) {
+        const cleanSensitive = sensitive.replace(/[-_]/g, "");
+        if (normalized.includes(cleanSensitive) && cleanSensitive.length >= 4) {
+          return true;
+        }
+      }
+      return false;
+    }
+    sanitize(value) {
+      const seen = /* @__PURE__ */ new WeakSet();
+      return this.sanitizeRecursive(value, 0, seen);
+    }
+    sanitizeRecursive(value, depth, seen) {
+      if (value === null || value === void 0) {
+        return value;
+      }
+      if (depth > this.maxDepth) {
+        return "[Max Depth Reached]";
+      }
+      const type = typeof value;
+      if (type === "string" || type === "number" || type === "boolean") {
+        return value;
+      }
+      if (type === "bigint") {
+        return value.toString() + "n";
+      }
+      if (type === "symbol") {
+        return value.toString();
+      }
+      if (type === "function") {
+        return `[Function: ${value.name || "anonymous"}]`;
+      }
+      if (typeof value === "object") {
+        if (seen.has(value)) {
+          return "[Circular Reference]";
+        }
+        seen.add(value);
+        if (value instanceof Error) {
+          return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack,
+            ...value
+          };
+        }
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (value instanceof RegExp) {
+          return value.toString();
+        }
+        if (typeof Element !== "undefined" && value instanceof Element) {
+          const id = value.id ? `#${value.id}` : "";
+          const className = value.className ? `.${String(value.className).trim().replace(/\s+/g, ".")}` : "";
+          return `<${value.tagName.toLowerCase()}${id}${className}>`;
+        }
+        if (Array.isArray(value)) {
+          const arr = value.slice(0, this.maxArrayLength).map(
+            (item) => this.sanitizeRecursive(item, depth + 1, seen)
+          );
+          if (value.length > this.maxArrayLength) {
+            arr.push(`[... ${value.length - this.maxArrayLength} more items]`);
+          }
+          return arr;
+        }
+        if (value instanceof Map) {
+          const entries = {};
+          for (const [k, v] of value.entries()) {
+            const keyStr = String(k);
+            entries[keyStr] = this.isSensitiveKey(keyStr) ? MASK_VALUE : this.sanitizeRecursive(v, depth + 1, seen);
+          }
+          return entries;
+        }
+        if (value instanceof Set) {
+          return Array.from(value).map(
+            (item) => this.sanitizeRecursive(item, depth + 1, seen)
+          );
+        }
+        const result = {};
+        const obj = value;
+        for (const [key, val] of Object.entries(obj)) {
+          if (this.isSensitiveKey(key)) {
+            result[key] = MASK_VALUE;
+          } else {
+            result[key] = this.sanitizeRecursive(val, depth + 1, seen);
+          }
+        }
+        return result;
+      }
+      return String(value);
+    }
+  }
+  const defaultSanitizer = new DataSanitizer();
+  function sanitize(value, options) {
+    if (!options) {
+      return defaultSanitizer.sanitize(value);
+    }
+    return new DataSanitizer(options).sanitize(value);
+  }
+
+  class CapDebugStore {
+    buffer = [];
+    maxEvents;
+    paused = false;
+    listeners = /* @__PURE__ */ new Set();
+    rafId = null;
+    customMaskKeys = [];
+    filterState = {
+      tab: "all",
+      search: "",
+      level: "all",
+      source: "all"
+    };
+    constructor(maxEvents = 500, customMaskKeys = []) {
+      this.maxEvents = Math.max(1, maxEvents);
+      this.customMaskKeys = customMaskKeys;
+    }
+    setMaxEvents(max) {
+      this.maxEvents = Math.max(1, max);
+      if (this.buffer.length > this.maxEvents) {
+        this.buffer = this.buffer.slice(this.buffer.length - this.maxEvents);
+        this.notify();
+      }
+    }
+    setCustomMaskKeys(keys) {
+      this.customMaskKeys = keys;
+    }
+    add(event) {
+      if (this.paused) {
+        return null;
+      }
+      const sanitizedData = event.data !== void 0 ? sanitize(event.data, { customMaskKeys: this.customMaskKeys }) : void 0;
+      const fullEvent = {
+        id: event.id || this.generateId(),
+        timestamp: event.timestamp || Date.now(),
+        source: event.source || "web",
+        type: event.type,
+        level: event.level || "info",
+        message: event.message,
+        data: sanitizedData,
+        duration: event.duration,
+        platform: event.platform
+      };
+      if (this.buffer.length >= this.maxEvents) {
+        this.buffer.shift();
+      }
+      this.buffer.push(fullEvent);
+      this.notify();
+      return fullEvent;
+    }
+    clear() {
+      this.buffer = [];
+      this.notify();
+    }
+    pause() {
+      this.paused = true;
+      this.notify();
+    }
+    resume() {
+      this.paused = false;
+      this.notify();
+    }
+    togglePause() {
+      this.paused = !this.paused;
+      this.notify();
+      return this.paused;
+    }
+    isPaused() {
+      return this.paused;
+    }
+    setFilter(partial) {
+      this.filterState = { ...this.filterState, ...partial };
+      this.notify();
+    }
+    getFilter() {
+      return this.filterState;
+    }
+    getAll() {
+      return [...this.buffer];
+    }
+    getCounts() {
+      const counts = {
+        all: this.buffer.length,
+        console: 0,
+        errors: 0,
+        events: 0,
+        native: 0,
+        device: 0,
+        network: 0,
+        bridge: 0
+      };
+      for (const ev of this.buffer) {
+        if (ev.source === "console") counts.console++;
+        if (ev.level === "error") counts.errors++;
+        if (ev.source === "web" || ev.source === "system") counts.events++;
+        if (ev.source === "native") counts.native++;
+        if (ev.source === "network") counts.network++;
+        if (ev.source === "bridge") counts.bridge++;
+      }
+      return counts;
+    }
+    getFiltered() {
+      const { tab, search, level, source } = this.filterState;
+      const query = search.trim().toLowerCase();
+      return this.buffer.filter((event) => {
+        if (tab === "console" && event.source !== "console") return false;
+        if (tab === "errors" && event.level !== "error") return false;
+        if (tab === "events" && (event.source !== "web" && event.source !== "system")) return false;
+        if (tab === "native" && event.source !== "native") return false;
+        if (tab === "network" && event.source !== "network") return false;
+        if (tab === "bridge" && event.source !== "bridge") return false;
+        if (level !== "all" && event.level !== level) return false;
+        if (source !== "all" && event.source !== source) return false;
+        if (query) {
+          const typeMatch = event.type.toLowerCase().includes(query);
+          const msgMatch = event.message ? event.message.toLowerCase().includes(query) : false;
+          const sourceMatch = event.source.toLowerCase().includes(query);
+          if (typeMatch || msgMatch || sourceMatch) return true;
+          if (event.data) {
+            try {
+              const dataStr = typeof event.data === "string" ? event.data.toLowerCase() : JSON.stringify(event.data).toLowerCase();
+              return dataStr.includes(query);
+            } catch {
+              return false;
             }
-            return String(value);
+          }
+          return false;
         }
+        return true;
+      });
     }
-    const defaultSanitizer = new DataSanitizer();
-    function sanitize(value, options) {
-        if (!options) {
-            return defaultSanitizer.sanitize(value);
-        }
-        return new DataSanitizer(options).sanitize(value);
+    exportJson() {
+      return JSON.stringify(
+        {
+          exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          totalEvents: this.buffer.length,
+          events: this.buffer
+        },
+        null,
+        2
+      );
+    }
+    subscribe(listener) {
+      this.listeners.add(listener);
+      listener(this.getFiltered(), this);
+      return () => {
+        this.listeners.delete(listener);
+      };
+    }
+    notify() {
+      if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
+        if (this.rafId !== null) {
+          cancelAnimationFrame(this.rafId);
+        }
+        this.rafId = requestAnimationFrame(() => {
+          this.rafId = null;
+          this.dispatchToListeners();
+        });
+      } else {
+        this.dispatchToListeners();
+      }
     }
+    dispatchToListeners() {
+      const filtered = this.getFiltered();
+      for (const listener of this.listeners) {
+        try {
+          listener(filtered, this);
+        } catch (err) {
+        }
+      }
+    }
+    generateId() {
+      return "ev_" + Math.random().toString(36).substring(2, 9) + "_" + Date.now().toString(36);
+    }
+  }
 
-    class CapDebugStore {
-        buffer = [];
-        maxEvents;
-        paused = false;
-        listeners = new Set();
-        rafId = null;
-        customMaskKeys = [];
-        filterState = {
-            tab: 'all',
-            search: '',
-            level: 'all',
-            source: 'all',
+  class ConsoleCollector {
+    id = "console";
+    running = false;
+    originalMethods = {};
+    start() {
+      if (this.running || typeof console === "undefined") return;
+      const methods = [
+        { method: "log", level: "info" },
+        { method: "info", level: "info" },
+        { method: "warn", level: "warn" },
+        { method: "error", level: "error" },
+        { method: "debug", level: "debug" }
+      ];
+      for (const { method, level } of methods) {
+        const original = console[method]?.bind(console);
+        this.originalMethods[method] = original;
+        console[method] = (...args) => {
+          if (original) {
+            try {
+              original(...args);
+            } catch {
+            }
+          }
+          try {
+            this.emitConsoleEvent(method, level, args);
+          } catch {
+          }
         };
-        constructor(maxEvents = 500, customMaskKeys = []) {
-            this.maxEvents = Math.max(1, maxEvents);
-            this.customMaskKeys = customMaskKeys;
-        }
-        setMaxEvents(max) {
-            this.maxEvents = Math.max(1, max);
-            if (this.buffer.length > this.maxEvents) {
-                this.buffer = this.buffer.slice(this.buffer.length - this.maxEvents);
-                this.notify();
-            }
-        }
-        setCustomMaskKeys(keys) {
-            this.customMaskKeys = keys;
-        }
-        add(event) {
-            if (this.paused) {
-                return null;
-            }
-            const sanitizedData = event.data !== undefined
-                ? sanitize(event.data, { customMaskKeys: this.customMaskKeys })
-                : undefined;
-            const fullEvent = {
-                id: event.id || this.generateId(),
-                timestamp: event.timestamp || Date.now(),
-                source: event.source || 'web',
-                type: event.type,
-                level: event.level || 'info',
-                message: event.message,
-                data: sanitizedData,
-                duration: event.duration,
-                platform: event.platform,
-            };
-            if (this.buffer.length >= this.maxEvents) {
-                this.buffer.shift(); // Evict oldest FIFO
-            }
-            this.buffer.push(fullEvent);
-            this.notify();
-            return fullEvent;
-        }
-        clear() {
-            this.buffer = [];
-            this.notify();
-        }
-        pause() {
-            this.paused = true;
-            this.notify();
-        }
-        resume() {
-            this.paused = false;
-            this.notify();
-        }
-        togglePause() {
-            this.paused = !this.paused;
-            this.notify();
-            return this.paused;
-        }
-        isPaused() {
-            return this.paused;
-        }
-        setFilter(partial) {
-            this.filterState = { ...this.filterState, ...partial };
-            this.notify();
-        }
-        getFilter() {
-            return this.filterState;
-        }
-        getAll() {
-            return [...this.buffer];
-        }
-        getCounts() {
-            const counts = {
-                all: this.buffer.length,
-                console: 0,
-                errors: 0,
-                events: 0,
-                native: 0,
-                device: 0,
-                network: 0,
-                bridge: 0,
-            };
-            for (const ev of this.buffer) {
-                if (ev.source === 'console')
-                    counts.console++;
-                if (ev.level === 'error')
-                    counts.errors++;
-                if (ev.source === 'web' || ev.source === 'system')
-                    counts.events++;
-                if (ev.source === 'native')
-                    counts.native++;
-                if (ev.source === 'network')
-                    counts.network++;
-                if (ev.source === 'bridge')
-                    counts.bridge++;
-            }
-            return counts;
-        }
-        getFiltered() {
-            const { tab, search, level, source } = this.filterState;
-            const query = search.trim().toLowerCase();
-            return this.buffer.filter(event => {
-                // 1. Tab filtering
-                if (tab === 'console' && event.source !== 'console')
-                    return false;
-                if (tab === 'errors' && event.level !== 'error')
-                    return false;
-                if (tab === 'events' && (event.source !== 'web' && event.source !== 'system'))
-                    return false;
-                if (tab === 'native' && event.source !== 'native')
-                    return false;
-                if (tab === 'network' && event.source !== 'network')
-                    return false;
-                if (tab === 'bridge' && event.source !== 'bridge')
-                    return false;
-                // 2. Level filter
-                if (level !== 'all' && event.level !== level)
-                    return false;
-                // 3. Source filter
-                if (source !== 'all' && event.source !== source)
-                    return false;
-                // 4. Search query
-                if (query) {
-                    const typeMatch = event.type.toLowerCase().includes(query);
-                    const msgMatch = event.message ? event.message.toLowerCase().includes(query) : false;
-                    const sourceMatch = event.source.toLowerCase().includes(query);
-                    if (typeMatch || msgMatch || sourceMatch)
-                        return true;
-                    if (event.data) {
-                        try {
-                            const dataStr = typeof event.data === 'string'
-                                ? event.data.toLowerCase()
-                                : JSON.stringify(event.data).toLowerCase();
-                            return dataStr.includes(query);
-                        }
-                        catch {
-                            return false;
-                        }
-                    }
-                    return false;
-                }
-                return true;
-            });
-        }
-        exportJson() {
-            return JSON.stringify({
-                exportedAt: new Date().toISOString(),
-                totalEvents: this.buffer.length,
-                events: this.buffer,
-            }, null, 2);
-        }
-        subscribe(listener) {
-            this.listeners.add(listener);
-            listener(this.getFiltered(), this);
-            return () => {
-                this.listeners.delete(listener);
-            };
-        }
-        notify() {
-            if (typeof window !== 'undefined' && typeof window.requestAnimationFrame === 'function') {
-                if (this.rafId !== null) {
-                    cancelAnimationFrame(this.rafId);
-                }
-                this.rafId = requestAnimationFrame(() => {
-                    this.rafId = null;
-                    this.dispatchToListeners();
-                });
-            }
-            else {
-                this.dispatchToListeners();
-            }
-        }
-        dispatchToListeners() {
-            const filtered = this.getFiltered();
-            for (const listener of this.listeners) {
-                try {
-                    listener(filtered, this);
-                }
-                catch (err) {
-                    // Prevent subscriber errors from halting store
-                }
-            }
-        }
-        generateId() {
-            return 'ev_' + Math.random().toString(36).substring(2, 9) + '_' + Date.now().toString(36);
-        }
-    }
-
-    class ConsoleCollector {
-        id = 'console';
-        running = false;
-        originalMethods = {};
-        start() {
-            if (this.running || typeof console === 'undefined')
-                return;
-            const methods = [
-                { method: 'log', level: 'info' },
-                { method: 'info', level: 'info' },
-                { method: 'warn', level: 'warn' },
-                { method: 'error', level: 'error' },
-                { method: 'debug', level: 'debug' },
-            ];
-            for (const { method, level } of methods) {
-                const original = console[method]?.bind(console);
-                this.originalMethods[method] = original;
-                console[method] = (...args) => {
-                    // 1. Call original console method
-                    if (original) {
-                        try {
-                            original(...args);
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }
-                    // 2. Dispatch CapDebug event safely
-                    try {
-                        this.emitConsoleEvent(method, level, args);
-                    }
-                    catch {
-                        // ignore to prevent crashing host application
-                    }
-                };
-            }
-            this.running = true;
-        }
-        stop() {
-            if (!this.running || typeof console === 'undefined')
-                return;
-            for (const method of Object.keys(this.originalMethods)) {
-                const original = this.originalMethods[method];
-                if (original) {
-                    console[method] = original;
-                }
-            }
-            this.originalMethods = {};
-            this.running = false;
-        }
-        emitConsoleEvent(method, level, args) {
-            if (typeof window === 'undefined')
-                return;
-            let message = '';
-            let data = undefined;
-            if (args.length === 1) {
-                const arg = args[0];
-                if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {
-                    message = String(arg);
-                }
-                else if (arg instanceof Error) {
-                    message = `${arg.name}: ${arg.message}`;
-                    data = { name: arg.name, message: arg.message, stack: arg.stack };
-                }
-                else {
-                    message = `[${typeof arg}]`;
-                    data = arg;
-                }
-            }
-            else if (args.length > 1) {
-                // Multiple arguments
-                const first = args[0];
-                if (typeof first === 'string') {
-                    message = first;
-                    data = args.slice(1);
-                }
-                else {
-                    message = args.map(a => (typeof a === 'object' && a !== null ? '[Object]' : String(a))).join(' ');
-                    data = args;
-                }
-            }
-            window.dispatchEvent(new CustomEvent('capdebug', {
-                detail: {
-                    source: 'console',
-                    type: `console.${method}`,
-                    level,
-                    message,
-                    data,
-                    timestamp: Date.now(),
+      }
+      this.running = true;
+    }
+    stop() {
+      if (!this.running || typeof console === "undefined") return;
+      for (const method of Object.keys(this.originalMethods)) {
+        const original = this.originalMethods[method];
+        if (original) {
+          console[method] = original;
+        }
+      }
+      this.originalMethods = {};
+      this.running = false;
+    }
+    emitConsoleEvent(method, level, args) {
+      if (typeof window === "undefined") return;
+      let message = "";
+      let data = void 0;
+      if (args.length === 1) {
+        const arg = args[0];
+        if (typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean") {
+          message = String(arg);
+        } else if (arg instanceof Error) {
+          message = `${arg.name}: ${arg.message}`;
+          data = { name: arg.name, message: arg.message, stack: arg.stack };
+        } else {
+          message = `[${typeof arg}]`;
+          data = arg;
+        }
+      } else if (args.length > 1) {
+        const first = args[0];
+        if (typeof first === "string") {
+          message = first;
+          data = args.slice(1);
+        } else {
+          message = args.map((a) => typeof a === "object" && a !== null ? "[Object]" : String(a)).join(" ");
+          data = args;
+        }
+      }
+      window.dispatchEvent(
+        new CustomEvent("capdebug", {
+          detail: {
+            source: "console",
+            type: `console.${method}`,
+            level,
+            message,
+            data,
+            timestamp: Date.now()
+          }
+        })
+      );
+    }
+  }
+
+  class ErrorCollector {
+    id = "error";
+    running = false;
+    errorHandler = null;
+    rejectionHandler = null;
+    start() {
+      if (this.running || typeof window === "undefined") return;
+      this.errorHandler = (event) => {
+        try {
+          const error = event.error;
+          const message = event.message || error && error.message || "Uncaught Error";
+          const stack = error && error.stack ? error.stack : void 0;
+          window.dispatchEvent(
+            new CustomEvent("capdebug", {
+              detail: {
+                source: "web",
+                type: "window.error",
+                level: "error",
+                message,
+                data: {
+                  filename: event.filename,
+                  lineno: event.lineno,
+                  colno: event.colno,
+                  stack,
+                  errorName: error?.name
                 },
-            }));
-        }
-    }
-
-    class ErrorCollector {
-        id = 'error';
-        running = false;
-        errorHandler = null;
-        rejectionHandler = null;
-        start() {
-            if (this.running || typeof window === 'undefined')
-                return;
-            this.errorHandler = (event) => {
-                try {
-                    const error = event.error;
-                    const message = event.message || (error && error.message) || 'Uncaught Error';
-                    const stack = error && error.stack ? error.stack : undefined;
-                    window.dispatchEvent(new CustomEvent('capdebug', {
-                        detail: {
-                            source: 'web',
-                            type: 'window.error',
-                            level: 'error',
-                            message,
-                            data: {
-                                filename: event.filename,
-                                lineno: event.lineno,
-                                colno: event.colno,
-                                stack,
-                                errorName: error?.name,
-                            },
-                            timestamp: Date.now(),
-                        },
-                    }));
-                }
-                catch {
-                    // ignore
-                }
-            };
-            this.rejectionHandler = (event) => {
-                try {
-                    const reason = event.reason;
-                    let message = 'Unhandled Promise Rejection';
-                    let stack = undefined;
-                    let data = reason;
-                    if (reason instanceof Error) {
-                        message = `Unhandled Rejection: ${reason.message}`;
-                        stack = reason.stack;
-                        data = {
-                            name: reason.name,
-                            message: reason.message,
-                            stack,
-                        };
-                    }
-                    else if (typeof reason === 'string') {
-                        message = `Unhandled Rejection: ${reason}`;
-                    }
-                    window.dispatchEvent(new CustomEvent('capdebug', {
-                        detail: {
-                            source: 'web',
-                            type: 'unhandledrejection',
-                            level: 'error',
-                            message,
-                            data: {
-                                reason: data,
-                                stack,
-                            },
-                            timestamp: Date.now(),
-                        },
-                    }));
-                }
-                catch {
-                    // ignore
-                }
+                timestamp: Date.now()
+              }
+            })
+          );
+        } catch {
+        }
+      };
+      this.rejectionHandler = (event) => {
+        try {
+          const reason = event.reason;
+          let message = "Unhandled Promise Rejection";
+          let stack = void 0;
+          let data = reason;
+          if (reason instanceof Error) {
+            message = `Unhandled Rejection: ${reason.message}`;
+            stack = reason.stack;
+            data = {
+              name: reason.name,
+              message: reason.message,
+              stack
             };
-            window.addEventListener('error', this.errorHandler);
-            window.addEventListener('unhandledrejection', this.rejectionHandler);
-            this.running = true;
-        }
-        stop() {
-            if (!this.running || typeof window === 'undefined')
-                return;
-            if (this.errorHandler) {
-                window.removeEventListener('error', this.errorHandler);
-                this.errorHandler = null;
-            }
-            if (this.rejectionHandler) {
-                window.removeEventListener('unhandledrejection', this.rejectionHandler);
-                this.rejectionHandler = null;
-            }
-            this.running = false;
-        }
+          } else if (typeof reason === "string") {
+            message = `Unhandled Rejection: ${reason}`;
+          }
+          window.dispatchEvent(
+            new CustomEvent("capdebug", {
+              detail: {
+                source: "web",
+                type: "unhandledrejection",
+                level: "error",
+                message,
+                data: {
+                  reason: data,
+                  stack
+                },
+                timestamp: Date.now()
+              }
+            })
+          );
+        } catch {
+        }
+      };
+      window.addEventListener("error", this.errorHandler);
+      window.addEventListener("unhandledrejection", this.rejectionHandler);
+      this.running = true;
+    }
+    stop() {
+      if (!this.running || typeof window === "undefined") return;
+      if (this.errorHandler) {
+        window.removeEventListener("error", this.errorHandler);
+        this.errorHandler = null;
+      }
+      if (this.rejectionHandler) {
+        window.removeEventListener("unhandledrejection", this.rejectionHandler);
+        this.rejectionHandler = null;
+      }
+      this.running = false;
     }
+  }
 
-    class NetworkCollector {
-        id = 'network';
-        running = false;
-        originalFetch = null;
-        options;
-        constructor(options = {}) {
-            this.options = {
-                body: false,
-                ...options,
-            };
-        }
-        setOptions(options) {
-            this.options = { ...this.options, ...options };
-        }
-        start() {
-            if (this.running || typeof window === 'undefined' || !window.fetch)
-                return;
-            this.originalFetch = window.fetch;
-            const self = this;
-            window.fetch = async function (input, init) {
-                const startTime = performance.now();
-                const timestamp = Date.now();
-                let url = '';
-                let method = 'GET';
-                if (typeof input === 'string') {
-                    url = input;
-                }
-                else if (input instanceof URL) {
-                    url = input.toString();
-                }
-                else if (typeof Request !== 'undefined' && input instanceof Request) {
-                    url = input.url;
-                    method = input.method;
-                }
-                if (init && init.method) {
-                    method = init.method.toUpperCase();
-                }
-                let requestHeaders = {};
-                if (init && init.headers) {
-                    if (typeof Headers !== 'undefined' && init.headers instanceof Headers) {
-                        init.headers.forEach((value, key) => {
-                            requestHeaders[key] = value;
-                        });
-                    }
-                    else if (Array.isArray(init.headers)) {
-                        for (const [k, v] of init.headers) {
-                            requestHeaders[k] = v;
-                        }
-                    }
-                    else if (typeof init.headers === 'object') {
-                        requestHeaders = { ...init.headers };
-                    }
-                }
-                let requestBody = undefined;
-                if (self.options.body && init && init.body) {
-                    try {
-                        if (typeof init.body === 'string') {
-                            try {
-                                requestBody = JSON.parse(init.body);
-                            }
-                            catch {
-                                requestBody = init.body;
-                            }
-                        }
-                        else {
-                            requestBody = '[Binary/Stream Body]';
-                        }
-                    }
-                    catch {
-                        requestBody = '[Unreadable Body]';
-                    }
-                }
-                try {
-                    const response = await self.originalFetch.call(this, input, init);
-                    const duration = Math.round(performance.now() - startTime);
-                    let level = 'info';
-                    if (response.status >= 500) {
-                        level = 'error';
-                    }
-                    else if (response.status >= 400) {
-                        level = 'warn';
-                    }
-                    let responseBody = undefined;
-                    if (self.options.body) {
-                        try {
-                            const clone = response.clone();
-                            const contentType = clone.headers.get('content-type') || '';
-                            if (contentType.includes('application/json')) {
-                                responseBody = await clone.json();
-                            }
-                            else if (contentType.includes('text/')) {
-                                responseBody = await clone.text();
-                            }
-                        }
-                        catch {
-                            responseBody = '[Could not clone response body]';
-                        }
-                    }
-                    const responseHeaders = {};
-                    response.headers.forEach((v, k) => {
-                        responseHeaders[k] = v;
-                    });
-                    self.emitNetworkEvent({
-                        type: `fetch ${method}`,
-                        level,
-                        message: `${method} ${url} → ${response.status} ${response.statusText} (${duration}ms)`,
-                        duration,
-                        timestamp,
-                        data: {
-                            method,
-                            url,
-                            status: response.status,
-                            statusText: response.statusText,
-                            ok: response.ok,
-                            duration,
-                            requestHeaders,
-                            responseHeaders,
-                            requestBody,
-                            responseBody,
-                        },
-                    });
-                    return response;
-                }
-                catch (err) {
-                    const duration = Math.round(performance.now() - startTime);
-                    self.emitNetworkEvent({
-                        type: `fetch ${method}`,
-                        level: 'error',
-                        message: `${method} ${url} → Failed: ${err?.message || 'Network Error'} (${duration}ms)`,
-                        duration,
-                        timestamp,
-                        data: {
-                            method,
-                            url,
-                            error: err?.message || String(err),
-                            duration,
-                            requestHeaders,
-                            requestBody,
-                        },
-                    });
-                    throw err;
-                }
-            };
-            this.running = true;
-        }
-        stop() {
-            if (!this.running || typeof window === 'undefined')
-                return;
-            if (this.originalFetch) {
-                window.fetch = this.originalFetch;
-                this.originalFetch = null;
-            }
-            this.running = false;
-        }
-        emitNetworkEvent(detail) {
-            if (typeof window === 'undefined')
-                return;
+  class NetworkCollector {
+    id = "network";
+    running = false;
+    originalFetch = null;
+    options;
+    constructor(options = {}) {
+      this.options = {
+        body: false,
+        ...options
+      };
+    }
+    setOptions(options) {
+      this.options = { ...this.options, ...options };
+    }
+    start() {
+      if (this.running || typeof window === "undefined" || !window.fetch) return;
+      this.originalFetch = window.fetch;
+      const self = this;
+      window.fetch = async function(input, init) {
+        const startTime = performance.now();
+        const timestamp = Date.now();
+        let url = "";
+        let method = "GET";
+        if (typeof input === "string") {
+          url = input;
+        } else if (input instanceof URL) {
+          url = input.toString();
+        } else if (typeof Request !== "undefined" && input instanceof Request) {
+          url = input.url;
+          method = input.method;
+        }
+        if (init && init.method) {
+          method = init.method.toUpperCase();
+        }
+        let requestHeaders = {};
+        if (init && init.headers) {
+          if (typeof Headers !== "undefined" && init.headers instanceof Headers) {
+            init.headers.forEach((value, key) => {
+              requestHeaders[key] = value;
+            });
+          } else if (Array.isArray(init.headers)) {
+            for (const [k, v] of init.headers) {
+              requestHeaders[k] = v;
+            }
+          } else if (typeof init.headers === "object") {
+            requestHeaders = { ...init.headers };
+          }
+        }
+        let requestBody = void 0;
+        if (self.options.body && init && init.body) {
+          try {
+            if (typeof init.body === "string") {
+              try {
+                requestBody = JSON.parse(init.body);
+              } catch {
+                requestBody = init.body;
+              }
+            } else {
+              requestBody = "[Binary/Stream Body]";
+            }
+          } catch {
+            requestBody = "[Unreadable Body]";
+          }
+        }
+        try {
+          const response = await self.originalFetch.call(this, input, init);
+          const duration = Math.round(performance.now() - startTime);
+          let level = "info";
+          if (response.status >= 500) {
+            level = "error";
+          } else if (response.status >= 400) {
+            level = "warn";
+          }
+          let responseBody = void 0;
+          if (self.options.body) {
             try {
-                window.dispatchEvent(new CustomEvent('capdebug', {
-                    detail: {
-                        source: 'network',
-                        ...detail,
-                    },
-                }));
-            }
-            catch {
-                // ignore
-            }
-        }
+              const clone = response.clone();
+              const contentType = clone.headers.get("content-type") || "";
+              if (contentType.includes("application/json")) {
+                responseBody = await clone.json();
+              } else if (contentType.includes("text/")) {
+                responseBody = await clone.text();
+              }
+            } catch {
+              responseBody = "[Could not clone response body]";
+            }
+          }
+          const responseHeaders = {};
+          response.headers.forEach((v, k) => {
+            responseHeaders[k] = v;
+          });
+          self.emitNetworkEvent({
+            type: `fetch ${method}`,
+            level,
+            message: `${method} ${url} \u2192 ${response.status} ${response.statusText} (${duration}ms)`,
+            duration,
+            timestamp,
+            data: {
+              method,
+              url,
+              status: response.status,
+              statusText: response.statusText,
+              ok: response.ok,
+              duration,
+              requestHeaders,
+              responseHeaders,
+              requestBody,
+              responseBody
+            }
+          });
+          return response;
+        } catch (err) {
+          const duration = Math.round(performance.now() - startTime);
+          self.emitNetworkEvent({
+            type: `fetch ${method}`,
+            level: "error",
+            message: `${method} ${url} \u2192 Failed: ${err?.message || "Network Error"} (${duration}ms)`,
+            duration,
+            timestamp,
+            data: {
+              method,
+              url,
+              error: err?.message || String(err),
+              duration,
+              requestHeaders,
+              requestBody
+            }
+          });
+          throw err;
+        }
+      };
+      this.running = true;
+    }
+    stop() {
+      if (!this.running || typeof window === "undefined") return;
+      if (this.originalFetch) {
+        window.fetch = this.originalFetch;
+        this.originalFetch = null;
+      }
+      this.running = false;
     }
+    emitNetworkEvent(detail) {
+      if (typeof window === "undefined") return;
+      try {
+        window.dispatchEvent(
+          new CustomEvent("capdebug", {
+            detail: {
+              source: "network",
+              ...detail
+            }
+          })
+        );
+      } catch {
+      }
+    }
+  }
 
-    class CustomEventCollector {
-        id = 'custom-event';
-        store;
-        running = false;
-        handler = null;
-        constructor(store) {
-            this.store = store;
-        }
-        start() {
-            if (this.running || typeof window === 'undefined')
-                return;
-            this.handler = (event) => {
-                const customEvent = event;
-                if (customEvent && customEvent.detail) {
-                    const detail = customEvent.detail;
-                    this.store.add({
-                        id: detail.id,
-                        timestamp: detail.timestamp || Date.now(),
-                        source: detail.source || 'web',
-                        type: detail.type || 'custom-event',
-                        level: detail.level || 'info',
-                        message: detail.message,
-                        data: detail.data,
-                        duration: detail.duration,
-                        platform: detail.platform,
-                    });
-                }
-            };
-            window.addEventListener('capdebug', this.handler);
-            this.running = true;
-        }
-        stop() {
-            if (!this.running || typeof window === 'undefined')
-                return;
-            if (this.handler) {
-                window.removeEventListener('capdebug', this.handler);
-                this.handler = null;
-            }
-            this.running = false;
-        }
-    }
-
-    class BrowserEventCollector {
-        id = 'browser-event';
-        running = false;
-        observedEvents = new Map();
-        start() {
-            this.running = true;
-        }
-        observe(eventName) {
-            if (!this.running || typeof window === 'undefined' || this.observedEvents.has(eventName))
-                return;
-            const listener = (event) => {
-                let data = {
-                    type: event.type,
-                    timeStamp: event.timeStamp,
-                };
-                if (event.type === 'visibilitychange' && typeof document !== 'undefined') {
-                    data.visibilityState = document.visibilityState;
-                    data.hidden = document.hidden;
-                }
-                else if (event.type === 'online' || event.type === 'offline') {
-                    data.onLine = typeof navigator !== 'undefined' ? navigator.onLine : undefined;
-                }
-                window.dispatchEvent(new CustomEvent('capdebug', {
-                    detail: {
-                        source: 'system',
-                        type: `event.${eventName}`,
-                        level: 'info',
-                        message: `Browser event fired: ${eventName}`,
-                        data,
-                        timestamp: Date.now(),
-                    },
-                }));
-            };
-            const target = eventName === 'visibilitychange' && typeof document !== 'undefined'
-                ? document
-                : window;
-            target.addEventListener(eventName, listener);
-            this.observedEvents.set(eventName, listener);
-        }
-        unobserve(eventName) {
-            const listener = this.observedEvents.get(eventName);
-            if (!listener)
-                return;
-            const target = eventName === 'visibilitychange' && typeof document !== 'undefined'
-                ? document
-                : window;
-            target.removeEventListener(eventName, listener);
-            this.observedEvents.delete(eventName);
-        }
-        stop() {
-            for (const [eventName, listener] of this.observedEvents.entries()) {
-                const target = eventName === 'visibilitychange' && typeof document !== 'undefined'
-                    ? document
-                    : window;
-                target.removeEventListener(eventName, listener);
-            }
-            this.observedEvents.clear();
-            this.running = false;
-        }
-    }
-
-    class BridgeCollector {
-        id = 'bridge';
-        running = false;
-        start() {
-            if (this.running)
-                return;
-            // Reserved for non-intrusive Capacitor bridge telemetry
-            this.running = true;
-        }
-        stop() {
-            this.running = false;
-        }
-        emitBridgeCall(pluginName, methodName, options, duration) {
-            if (!this.running || typeof window === 'undefined')
-                return;
-            window.dispatchEvent(new CustomEvent('capdebug', {
-                detail: {
-                    source: 'bridge',
-                    type: `${pluginName}.${methodName}`,
-                    level: 'debug',
-                    message: `Bridge call: ${pluginName}.${methodName}`,
-                    data: options,
-                    duration,
-                    timestamp: Date.now(),
-                },
-            }));
-        }
+  class CustomEventCollector {
+    id = "custom-event";
+    store;
+    running = false;
+    handler = null;
+    constructor(store) {
+      this.store = store;
+    }
+    start() {
+      if (this.running || typeof window === "undefined") return;
+      this.handler = (event) => {
+        const customEvent = event;
+        if (customEvent && customEvent.detail) {
+          const detail = customEvent.detail;
+          this.store.add({
+            id: detail.id,
+            timestamp: detail.timestamp || Date.now(),
+            source: detail.source || "web",
+            type: detail.type || "custom-event",
+            level: detail.level || "info",
+            message: detail.message,
+            data: detail.data,
+            duration: detail.duration,
+            platform: detail.platform
+          });
+        }
+      };
+      window.addEventListener("capdebug", this.handler);
+      this.running = true;
     }
+    stop() {
+      if (!this.running || typeof window === "undefined") return;
+      if (this.handler) {
+        window.removeEventListener("capdebug", this.handler);
+        this.handler = null;
+      }
+      this.running = false;
+    }
+  }
 
-    const VIEWER_STYLES = `
+  class BrowserEventCollector {
+    id = "browser-event";
+    running = false;
+    observedEvents = /* @__PURE__ */ new Map();
+    start() {
+      this.running = true;
+    }
+    observe(eventName) {
+      if (!this.running || typeof window === "undefined" || this.observedEvents.has(eventName)) return;
+      const listener = (event) => {
+        let data = {
+          type: event.type,
+          timeStamp: event.timeStamp
+        };
+        if (event.type === "visibilitychange" && typeof document !== "undefined") {
+          data.visibilityState = document.visibilityState;
+          data.hidden = document.hidden;
+        } else if (event.type === "online" || event.type === "offline") {
+          data.onLine = typeof navigator !== "undefined" ? navigator.onLine : void 0;
+        }
+        window.dispatchEvent(
+          new CustomEvent("capdebug", {
+            detail: {
+              source: "system",
+              type: `event.${eventName}`,
+              level: "info",
+              message: `Browser event fired: ${eventName}`,
+              data,
+              timestamp: Date.now()
+            }
+          })
+        );
+      };
+      const target = eventName === "visibilitychange" && typeof document !== "undefined" ? document : window;
+      target.addEventListener(eventName, listener);
+      this.observedEvents.set(eventName, listener);
+    }
+    unobserve(eventName) {
+      const listener = this.observedEvents.get(eventName);
+      if (!listener) return;
+      const target = eventName === "visibilitychange" && typeof document !== "undefined" ? document : window;
+      target.removeEventListener(eventName, listener);
+      this.observedEvents.delete(eventName);
+    }
+    stop() {
+      for (const [eventName, listener] of this.observedEvents.entries()) {
+        const target = eventName === "visibilitychange" && typeof document !== "undefined" ? document : window;
+        target.removeEventListener(eventName, listener);
+      }
+      this.observedEvents.clear();
+      this.running = false;
+    }
+  }
+
+  class BridgeCollector {
+    id = "bridge";
+    running = false;
+    start() {
+      if (this.running) return;
+      this.running = true;
+    }
+    stop() {
+      this.running = false;
+    }
+    emitBridgeCall(pluginName, methodName, options, duration) {
+      if (!this.running || typeof window === "undefined") return;
+      window.dispatchEvent(
+        new CustomEvent("capdebug", {
+          detail: {
+            source: "bridge",
+            type: `${pluginName}.${methodName}`,
+            level: "debug",
+            message: `Bridge call: ${pluginName}.${methodName}`,
+            data: options,
+            duration,
+            timestamp: Date.now()
+          }
+        })
+      );
+    }
+  }
+
+  const VIEWER_STYLES = `
 :host {
   --cd-bg-base: #0d1117;
   --cd-bg-surface: #161b22;
@@ -1564,1226 +1494,2023 @@ var capacitorCapDebug = (function (exports, core) {
 }
 `;
 
-    const STORAGE_KEY = 'capdebug_btn_pos';
-    class FloatingButton {
-        element;
-        badgeElement;
-        options;
-        isDragging = false;
-        hasMoved = false;
-        startX = 0;
-        startY = 0;
-        initialLeft = 0;
-        initialTop = 0;
-        constructor(options = {}) {
-            this.options = {
-                position: 'right',
-                persistPosition: true,
-                ...options,
-            };
-            this.element = document.createElement('div');
-            this.element.className = 'cd-floating-btn';
-            this.element.setAttribute('role', 'button');
-            this.element.setAttribute('aria-label', 'Open CapDebug');
-            const logo = document.createElement('span');
-            logo.className = 'cd-btn-logo';
-            logo.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="margin-right: 4px"><path d="m8 2 1.88 1.88"/><path d="M14.12 3.88 16 2"/><path d="M9 7.13v-1a3.003 3.003 0 1 1 6 0v1"/><path d="M12 20c-3.3 0-6-2.7-6-6v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 4v3c0 3.3-2.7 6-6 6"/><path d="M12 20v-9"/><path d="M6.53 9C4.6 8.8 3 7.1 3 5"/><path d="M6 13H2"/><path d="M3 21c0-2.1 1.7-3.9 3.8-4"/><path d="M20.97 5c0 2.1-1.6 3.8-3.5 4"/><path d="M22 13h-4"/><path d="M17.2 17c2.1.1 3.8 1.9 3.8 4"/></svg>CAP`;
-            this.badgeElement = document.createElement('span');
-            this.badgeElement.className = 'cd-btn-badge';
-            this.badgeElement.textContent = '0';
-            this.element.appendChild(logo);
-            this.element.appendChild(this.badgeElement);
-            this.initPosition();
-            this.bindEvents();
-        }
-        getElement() {
-            return this.element;
-        }
-        setErrorCount(count) {
-            if (count > 0) {
-                this.badgeElement.textContent = count > 99 ? '99+' : String(count);
-                this.badgeElement.classList.add('visible');
-            }
-            else {
-                this.badgeElement.classList.remove('visible');
-            }
-        }
-        show() {
-            this.element.style.display = 'flex';
-        }
-        hide() {
-            this.element.style.display = 'none';
-        }
-        initPosition() {
-            let savedPos = null;
-            if (this.options.persistPosition && typeof localStorage !== 'undefined') {
-                try {
-                    const stored = localStorage.getItem(STORAGE_KEY);
-                    if (stored) {
-                        savedPos = JSON.parse(stored);
-                    }
-                }
-                catch {
-                    // ignore
-                }
-            }
-            const windowWidth = typeof window !== 'undefined' ? window.innerWidth : 400;
-            const windowHeight = typeof window !== 'undefined' ? window.innerHeight : 800;
-            let x = windowWidth - 76;
-            let y = Math.max(80, windowHeight * 0.4);
-            if (savedPos && typeof savedPos.x === 'number' && typeof savedPos.y === 'number') {
-                x = Math.min(Math.max(10, savedPos.x), windowWidth - 76);
-                y = Math.min(Math.max(60, savedPos.y), windowHeight - 60);
-            }
-            else if (typeof this.options.position === 'object') {
-                x = this.options.position.x;
-                y = this.options.position.y;
-            }
-            else if (this.options.position === 'left') {
-                x = 12;
-            }
-            this.setPosition(x, y);
-        }
-        setPosition(x, y) {
-            this.element.style.left = `${x}px`;
-            this.element.style.top = `${y}px`;
-            this.element.style.right = 'auto';
-            this.element.style.bottom = 'auto';
-        }
-        bindEvents() {
-            const onPointerDown = (e) => {
-                this.isDragging = true;
-                this.hasMoved = false;
-                this.startX = e.clientX;
-                this.startY = e.clientY;
-                const rect = this.element.getBoundingClientRect();
-                this.initialLeft = rect.left;
-                this.initialTop = rect.top;
-                this.element.classList.add('dragging');
-                this.element.setPointerCapture(e.pointerId);
-            };
-            const onPointerMove = (e) => {
-                if (!this.isDragging)
-                    return;
-                const deltaX = e.clientX - this.startX;
-                const deltaY = e.clientY - this.startY;
-                if (Math.abs(deltaX) > 4 || Math.abs(deltaY) > 4) {
-                    this.hasMoved = true;
-                }
-                let newX = this.initialLeft + deltaX;
-                let newY = this.initialTop + deltaY;
-                const maxX = window.innerWidth - this.element.offsetWidth - 8;
-                const maxY = window.innerHeight - this.element.offsetHeight - 8;
-                newX = Math.max(8, Math.min(newX, maxX));
-                newY = Math.max(40, Math.min(newY, maxY));
-                this.setPosition(newX, newY);
-            };
-            const onPointerUp = (e) => {
-                if (!this.isDragging)
-                    return;
-                this.isDragging = false;
-                this.element.classList.remove('dragging');
-                try {
-                    this.element.releasePointerCapture(e.pointerId);
-                }
-                catch {
-                    // ignore
-                }
-                if (!this.hasMoved) {
-                    // Tap / Click action
-                    if (this.options.onClick) {
-                        this.options.onClick();
-                    }
-                }
-                else {
-                    // Snap to nearest edge (left or right)
-                    this.snapToEdge();
-                }
-            };
-            this.element.addEventListener('pointerdown', onPointerDown);
-            this.element.addEventListener('pointermove', onPointerMove);
-            this.element.addEventListener('pointerup', onPointerUp);
-            this.element.addEventListener('pointercancel', onPointerUp);
-        }
-        snapToEdge() {
-            const rect = this.element.getBoundingClientRect();
-            const windowWidth = window.innerWidth;
-            const windowHeight = window.innerHeight;
-            const snapLeft = 12;
-            const snapRight = windowWidth - rect.width - 12;
-            const targetX = rect.left + rect.width / 2 < windowWidth / 2 ? snapLeft : snapRight;
-            const targetY = Math.max(50, Math.min(rect.top, windowHeight - rect.height - 50));
-            this.element.style.transition = 'left 0.2s cubic-bezier(0.16, 1, 0.3, 1), top 0.2s cubic-bezier(0.16, 1, 0.3, 1)';
-            this.setPosition(targetX, targetY);
-            setTimeout(() => {
-                this.element.style.transition = '';
-            }, 200);
-            if (this.options.persistPosition && typeof localStorage !== 'undefined') {
-                try {
-                    localStorage.setItem(STORAGE_KEY, JSON.stringify({ x: targetX, y: targetY }));
-                }
-                catch {
-                    // ignore
-                }
-            }
-        }
+  const STORAGE_KEY = "capdebug_btn_pos";
+  class FloatingButton {
+    element;
+    badgeElement;
+    options;
+    isDragging = false;
+    hasMoved = false;
+    startX = 0;
+    startY = 0;
+    initialLeft = 0;
+    initialTop = 0;
+    constructor(options = {}) {
+      this.options = {
+        position: "right",
+        persistPosition: true,
+        ...options
+      };
+      this.element = document.createElement("div");
+      this.element.className = "cd-floating-btn";
+      this.element.setAttribute("role", "button");
+      this.element.setAttribute("aria-label", "Open CapDebug");
+      const logo = document.createElement("span");
+      logo.className = "cd-btn-logo";
+      logo.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="margin-right: 4px"><path d="m8 2 1.88 1.88"/><path d="M14.12 3.88 16 2"/><path d="M9 7.13v-1a3.003 3.003 0 1 1 6 0v1"/><path d="M12 20c-3.3 0-6-2.7-6-6v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 4v3c0 3.3-2.7 6-6 6"/><path d="M12 20v-9"/><path d="M6.53 9C4.6 8.8 3 7.1 3 5"/><path d="M6 13H2"/><path d="M3 21c0-2.1 1.7-3.9 3.8-4"/><path d="M20.97 5c0 2.1-1.6 3.8-3.5 4"/><path d="M22 13h-4"/><path d="M17.2 17c2.1.1 3.8 1.9 3.8 4"/></svg>CAP`;
+      this.badgeElement = document.createElement("span");
+      this.badgeElement.className = "cd-btn-badge";
+      this.badgeElement.textContent = "0";
+      this.element.appendChild(logo);
+      this.element.appendChild(this.badgeElement);
+      this.initPosition();
+      this.bindEvents();
+    }
+    getElement() {
+      return this.element;
+    }
+    setErrorCount(count) {
+      if (count > 0) {
+        this.badgeElement.textContent = count > 99 ? "99+" : String(count);
+        this.badgeElement.classList.add("visible");
+      } else {
+        this.badgeElement.classList.remove("visible");
+      }
+    }
+    show() {
+      this.element.style.display = "flex";
+    }
+    hide() {
+      this.element.style.display = "none";
     }
+    initPosition() {
+      let savedPos = null;
+      if (this.options.persistPosition && typeof localStorage !== "undefined") {
+        try {
+          const stored = localStorage.getItem(STORAGE_KEY);
+          if (stored) {
+            savedPos = JSON.parse(stored);
+          }
+        } catch {
+        }
+      }
+      const windowWidth = typeof window !== "undefined" ? window.innerWidth : 400;
+      const windowHeight = typeof window !== "undefined" ? window.innerHeight : 800;
+      let x = windowWidth - 76;
+      let y = Math.max(80, windowHeight * 0.4);
+      if (savedPos && typeof savedPos.x === "number" && typeof savedPos.y === "number") {
+        x = Math.min(Math.max(10, savedPos.x), windowWidth - 76);
+        y = Math.min(Math.max(60, savedPos.y), windowHeight - 60);
+      } else if (typeof this.options.position === "object") {
+        x = this.options.position.x;
+        y = this.options.position.y;
+      } else if (this.options.position === "left") {
+        x = 12;
+      }
+      this.setPosition(x, y);
+    }
+    setPosition(x, y) {
+      this.element.style.left = `${x}px`;
+      this.element.style.top = `${y}px`;
+      this.element.style.right = "auto";
+      this.element.style.bottom = "auto";
+    }
+    bindEvents() {
+      const onPointerDown = (e) => {
+        this.isDragging = true;
+        this.hasMoved = false;
+        this.startX = e.clientX;
+        this.startY = e.clientY;
+        const rect = this.element.getBoundingClientRect();
+        this.initialLeft = rect.left;
+        this.initialTop = rect.top;
+        this.element.classList.add("dragging");
+        this.element.setPointerCapture(e.pointerId);
+      };
+      const onPointerMove = (e) => {
+        if (!this.isDragging) return;
+        const deltaX = e.clientX - this.startX;
+        const deltaY = e.clientY - this.startY;
+        if (Math.abs(deltaX) > 4 || Math.abs(deltaY) > 4) {
+          this.hasMoved = true;
+        }
+        let newX = this.initialLeft + deltaX;
+        let newY = this.initialTop + deltaY;
+        const maxX = window.innerWidth - this.element.offsetWidth - 8;
+        const maxY = window.innerHeight - this.element.offsetHeight - 8;
+        newX = Math.max(8, Math.min(newX, maxX));
+        newY = Math.max(40, Math.min(newY, maxY));
+        this.setPosition(newX, newY);
+      };
+      const onPointerUp = (e) => {
+        if (!this.isDragging) return;
+        this.isDragging = false;
+        this.element.classList.remove("dragging");
+        try {
+          this.element.releasePointerCapture(e.pointerId);
+        } catch {
+        }
+        if (!this.hasMoved) {
+          if (this.options.onClick) {
+            this.options.onClick();
+          }
+        } else {
+          this.snapToEdge();
+        }
+      };
+      this.element.addEventListener("pointerdown", onPointerDown);
+      this.element.addEventListener("pointermove", onPointerMove);
+      this.element.addEventListener("pointerup", onPointerUp);
+      this.element.addEventListener("pointercancel", onPointerUp);
+    }
+    snapToEdge() {
+      const rect = this.element.getBoundingClientRect();
+      const windowWidth = window.innerWidth;
+      const windowHeight = window.innerHeight;
+      const snapLeft = 12;
+      const snapRight = windowWidth - rect.width - 12;
+      const targetX = rect.left + rect.width / 2 < windowWidth / 2 ? snapLeft : snapRight;
+      const targetY = Math.max(50, Math.min(rect.top, windowHeight - rect.height - 50));
+      this.element.style.transition = "left 0.2s cubic-bezier(0.16, 1, 0.3, 1), top 0.2s cubic-bezier(0.16, 1, 0.3, 1)";
+      this.setPosition(targetX, targetY);
+      setTimeout(() => {
+        this.element.style.transition = "";
+      }, 200);
+      if (this.options.persistPosition && typeof localStorage !== "undefined") {
+        try {
+          localStorage.setItem(STORAGE_KEY, JSON.stringify({ x: targetX, y: targetY }));
+        } catch {
+        }
+      }
+    }
+  }
 
-    class JsonViewer {
-        static render(data, initialExpandedDepth = 2) {
-            const container = document.createElement('div');
-            container.className = 'cd-json-tree';
-            if (data === undefined) {
-                const undefinedSpan = document.createElement('span');
-                undefinedSpan.className = 'cd-json-null';
-                undefinedSpan.textContent = 'undefined';
-                container.appendChild(undefinedSpan);
-                return container;
-            }
-            const rootNode = JsonViewer.renderNode('', data, 0, initialExpandedDepth);
-            container.appendChild(rootNode);
-            return container;
-        }
-        static renderNode(key, value, depth, maxExpandedDepth) {
-            const node = document.createElement('div');
-            node.className = 'cd-json-node';
-            const row = document.createElement('div');
-            row.className = 'cd-json-row';
-            const isObject = typeof value === 'object' && value !== null;
-            const isArray = Array.isArray(value);
-            // Toggle button for objects/arrays
-            if (isObject) {
-                const toggle = document.createElement('span');
-                toggle.className = 'cd-json-toggle';
-                toggle.innerHTML = '▼';
-                row.appendChild(toggle);
-            }
-            else {
-                const spacer = document.createElement('span');
-                spacer.style.width = '14px';
-                spacer.style.display = 'inline-block';
-                row.appendChild(spacer);
-            }
-            // Key (if present)
-            if (key !== '') {
-                const keySpan = document.createElement('span');
-                keySpan.className = 'cd-json-key';
-                keySpan.textContent = typeof key === 'number' ? `[${key}]` : `"${key}"`;
-                row.appendChild(keySpan);
-                const colonSpan = document.createElement('span');
-                colonSpan.className = 'cd-json-colon';
-                colonSpan.textContent = ': ';
-                row.appendChild(colonSpan);
-            }
-            // Value preview or primitive
-            if (isObject) {
-                const entries = isArray
-                    ? value.map((v, i) => [i, v])
-                    : Object.entries(value);
-                const bracketOpen = isArray ? '[' : '{';
-                const bracketClose = isArray ? ']' : '}';
-                const previewSpan = document.createElement('span');
-                previewSpan.className = 'cd-json-colon';
-                previewSpan.textContent = `${bracketOpen} ${entries.length} ${isArray ? 'items' : 'keys'} ${bracketClose}`;
-                row.appendChild(previewSpan);
-                // Copy object JSON button
-                const copyBtn = document.createElement('button');
-                copyBtn.className = 'cd-json-copy-btn';
-                copyBtn.textContent = 'copy';
-                copyBtn.title = 'Copy branch JSON';
-                copyBtn.addEventListener('click', e => {
-                    e.stopPropagation();
-                    JsonViewer.copyToClipboard(JSON.stringify(value, null, 2), copyBtn);
-                });
-                row.appendChild(copyBtn);
-                node.appendChild(row);
-                // Children container
-                const childrenContainer = document.createElement('div');
-                childrenContainer.className = 'cd-json-children';
-                const isInitiallyExpanded = depth < maxExpandedDepth;
-                if (!isInitiallyExpanded) {
-                    childrenContainer.classList.add('hidden');
-                    const toggle = row.querySelector('.cd-json-toggle');
-                    if (toggle)
-                        toggle.classList.add('collapsed');
-                }
-                for (const [childKey, childVal] of entries) {
-                    childrenContainer.appendChild(JsonViewer.renderNode(childKey, childVal, depth + 1, maxExpandedDepth));
-                }
-                node.appendChild(childrenContainer);
-                // Toggle collapse on row or toggle click
-                row.addEventListener('click', e => {
-                    if (e.target.tagName.toLowerCase() === 'button')
-                        return;
-                    const toggle = row.querySelector('.cd-json-toggle');
-                    const isHidden = childrenContainer.classList.toggle('hidden');
-                    if (toggle) {
-                        toggle.classList.toggle('collapsed', isHidden);
-                    }
-                });
-            }
-            else {
-                // Primitive value
-                const valSpan = document.createElement('span');
-                const valType = typeof value;
-                if (value === null) {
-                    valSpan.className = 'cd-json-null';
-                    valSpan.textContent = 'null';
-                }
-                else if (valType === 'string') {
-                    valSpan.className = 'cd-json-string';
-                    valSpan.textContent = `"${value}"`;
-                }
-                else if (valType === 'number') {
-                    valSpan.className = 'cd-json-number';
-                    valSpan.textContent = String(value);
-                }
-                else if (valType === 'boolean') {
-                    valSpan.className = 'cd-json-boolean';
-                    valSpan.textContent = String(value);
-                }
-                else {
-                    valSpan.className = 'cd-json-null';
-                    valSpan.textContent = String(value);
-                }
-                row.appendChild(valSpan);
-                // Copy primitive value button
-                const copyBtn = document.createElement('button');
-                copyBtn.className = 'cd-json-copy-btn';
-                copyBtn.textContent = 'copy';
-                copyBtn.title = 'Copy value';
-                copyBtn.addEventListener('click', e => {
-                    e.stopPropagation();
-                    JsonViewer.copyToClipboard(String(value), copyBtn);
-                });
-                row.appendChild(copyBtn);
-                node.appendChild(row);
-            }
-            return node;
-        }
-        static async copyToClipboard(text, triggerBtn) {
-            try {
-                if (navigator.clipboard && window.isSecureContext) {
-                    await navigator.clipboard.writeText(text);
-                }
-                else {
-                    const textarea = document.createElement('textarea');
-                    textarea.value = text;
-                    textarea.style.position = 'fixed';
-                    textarea.style.left = '-9999px';
-                    textarea.style.top = '-9999px';
-                    document.body.appendChild(textarea);
-                    textarea.focus();
-                    textarea.select();
-                    document.execCommand('copy');
-                    document.body.removeChild(textarea);
-                }
-                if (triggerBtn) {
-                    const originalText = triggerBtn.textContent;
-                    triggerBtn.textContent = 'copied!';
-                    triggerBtn.style.color = '#34d399';
-                    setTimeout(() => {
-                        triggerBtn.textContent = originalText;
-                        triggerBtn.style.color = '';
-                    }, 1500);
-                }
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
+  class JsonViewer {
+    static render(data, initialExpandedDepth = 2) {
+      const container = document.createElement("div");
+      container.className = "cd-json-tree";
+      if (data === void 0) {
+        const undefinedSpan = document.createElement("span");
+        undefinedSpan.className = "cd-json-null";
+        undefinedSpan.textContent = "undefined";
+        container.appendChild(undefinedSpan);
+        return container;
+      }
+      const rootNode = JsonViewer.renderNode("", data, 0, initialExpandedDepth);
+      container.appendChild(rootNode);
+      return container;
+    }
+    static renderNode(key, value, depth, maxExpandedDepth) {
+      const node = document.createElement("div");
+      node.className = "cd-json-node";
+      const row = document.createElement("div");
+      row.className = "cd-json-row";
+      const isObject = typeof value === "object" && value !== null;
+      const isArray = Array.isArray(value);
+      if (isObject) {
+        const toggle = document.createElement("span");
+        toggle.className = "cd-json-toggle";
+        toggle.innerHTML = "\u25BC";
+        row.appendChild(toggle);
+      } else {
+        const spacer = document.createElement("span");
+        spacer.style.width = "14px";
+        spacer.style.display = "inline-block";
+        row.appendChild(spacer);
+      }
+      if (key !== "") {
+        const keySpan = document.createElement("span");
+        keySpan.className = "cd-json-key";
+        keySpan.textContent = typeof key === "number" ? `[${key}]` : `"${key}"`;
+        row.appendChild(keySpan);
+        const colonSpan = document.createElement("span");
+        colonSpan.className = "cd-json-colon";
+        colonSpan.textContent = ": ";
+        row.appendChild(colonSpan);
+      }
+      if (isObject) {
+        const entries = isArray ? value.map((v, i) => [i, v]) : Object.entries(value);
+        const bracketOpen = isArray ? "[" : "{";
+        const bracketClose = isArray ? "]" : "}";
+        const previewSpan = document.createElement("span");
+        previewSpan.className = "cd-json-colon";
+        previewSpan.textContent = `${bracketOpen} ${entries.length} ${isArray ? "items" : "keys"} ${bracketClose}`;
+        row.appendChild(previewSpan);
+        const copyBtn = document.createElement("button");
+        copyBtn.className = "cd-json-copy-btn";
+        copyBtn.textContent = "copy";
+        copyBtn.title = "Copy branch JSON";
+        copyBtn.addEventListener("click", (e) => {
+          e.stopPropagation();
+          JsonViewer.copyToClipboard(JSON.stringify(value, null, 2), copyBtn);
+        });
+        row.appendChild(copyBtn);
+        node.appendChild(row);
+        const childrenContainer = document.createElement("div");
+        childrenContainer.className = "cd-json-children";
+        const isInitiallyExpanded = depth < maxExpandedDepth;
+        if (!isInitiallyExpanded) {
+          childrenContainer.classList.add("hidden");
+          const toggle = row.querySelector(".cd-json-toggle");
+          if (toggle) toggle.classList.add("collapsed");
+        }
+        for (const [childKey, childVal] of entries) {
+          childrenContainer.appendChild(
+            JsonViewer.renderNode(childKey, childVal, depth + 1, maxExpandedDepth)
+          );
+        }
+        node.appendChild(childrenContainer);
+        row.addEventListener("click", (e) => {
+          if (e.target.tagName.toLowerCase() === "button") return;
+          const toggle = row.querySelector(".cd-json-toggle");
+          const isHidden = childrenContainer.classList.toggle("hidden");
+          if (toggle) {
+            toggle.classList.toggle("collapsed", isHidden);
+          }
+        });
+      } else {
+        const valSpan = document.createElement("span");
+        const valType = typeof value;
+        if (value === null) {
+          valSpan.className = "cd-json-null";
+          valSpan.textContent = "null";
+        } else if (valType === "string") {
+          valSpan.className = "cd-json-string";
+          valSpan.textContent = `"${value}"`;
+        } else if (valType === "number") {
+          valSpan.className = "cd-json-number";
+          valSpan.textContent = String(value);
+        } else if (valType === "boolean") {
+          valSpan.className = "cd-json-boolean";
+          valSpan.textContent = String(value);
+        } else {
+          valSpan.className = "cd-json-null";
+          valSpan.textContent = String(value);
+        }
+        row.appendChild(valSpan);
+        const copyBtn = document.createElement("button");
+        copyBtn.className = "cd-json-copy-btn";
+        copyBtn.textContent = "copy";
+        copyBtn.title = "Copy value";
+        copyBtn.addEventListener("click", (e) => {
+          e.stopPropagation();
+          JsonViewer.copyToClipboard(String(value), copyBtn);
+        });
+        row.appendChild(copyBtn);
+        node.appendChild(row);
+      }
+      return node;
+    }
+    static async copyToClipboard(text, triggerBtn) {
+      try {
+        if (navigator.clipboard && window.isSecureContext) {
+          await navigator.clipboard.writeText(text);
+        } else {
+          const textarea = document.createElement("textarea");
+          textarea.value = text;
+          textarea.style.position = "fixed";
+          textarea.style.left = "-9999px";
+          textarea.style.top = "-9999px";
+          document.body.appendChild(textarea);
+          textarea.focus();
+          textarea.select();
+          document.execCommand("copy");
+          document.body.removeChild(textarea);
+        }
+        if (triggerBtn) {
+          const originalText = triggerBtn.textContent;
+          triggerBtn.textContent = "copied!";
+          triggerBtn.style.color = "#34d399";
+          setTimeout(() => {
+            triggerBtn.textContent = originalText;
+            triggerBtn.style.color = "";
+          }, 1500);
+        }
+        return true;
+      } catch {
+        return false;
+      }
     }
+  }
 
-    const CapDebugNative = core.registerPlugin('CapDebug', {
-        web: () => Promise.resolve().then(function () { return web; }).then(m => new m.CapDebugWeb()),
-    });
-
-    class DebugPanel {
-        element;
-        backdrop;
-        store;
-        options;
-        isOpen = false;
-        // Header UI
-        statusIndicator;
-        titleCountSpan;
-        pauseBtn;
-        // Tab elements
-        tabElements = new Map();
-        tabBadgeElements = new Map();
-        // Search & Filter UI
-        searchInput;
-        levelPills = new Map();
-        // Content
-        contentContainer;
-        eventListContainer;
-        deviceViewContainer;
-        // Detail Overlay
-        detailOverlay;
-        selectedEvent = null;
-        // Device tab state
-        isDeviceLoading = false;
-        deviceData = null;
-        constructor(store, options = {}) {
-            this.store = store;
-            this.options = {
-                defaultTab: 'all',
-                ...options,
-            };
-            this.backdrop = document.createElement('div');
-            this.backdrop.className = 'cd-backdrop';
-            this.element = document.createElement('div');
-            this.element.className = 'cd-panel';
-            this.buildUI();
-            this.bindStore();
-            if (this.options.defaultTab) {
-                this.store.setFilter({ tab: this.options.defaultTab });
-            }
-        }
-        getElement() {
-            return this.element;
-        }
-        getBackdrop() {
-            return this.backdrop;
-        }
-        open() {
-            this.isOpen = true;
-            this.element.classList.add('open');
-            this.backdrop.classList.add('open');
-            // If device tab is active, trigger lazy load
-            if (this.store.getFilter().tab === 'device') {
-                this.loadDeviceDiagnostics();
-            }
-        }
-        close() {
-            this.isOpen = false;
-            this.element.classList.remove('open');
-            this.backdrop.classList.remove('open');
-            this.closeDetail();
-            if (this.options.onClose) {
-                this.options.onClose();
-            }
-        }
-        toggle() {
-            if (this.isOpen) {
-                this.close();
-                return false;
-            }
-            else {
-                this.open();
-                return true;
-            }
-        }
-        isPanelOpen() {
-            return this.isOpen;
-        }
-        buildUI() {
-            this.backdrop.addEventListener('click', () => this.close());
-            // 1. Header
-            const header = document.createElement('div');
-            header.className = 'cd-header';
-            const headerLeft = document.createElement('div');
-            headerLeft.className = 'cd-header-left';
-            this.statusIndicator = document.createElement('div');
-            this.statusIndicator.className = 'cd-status-indicator';
-            this.statusIndicator.title = 'CapDebug Active';
-            const headerTitle = document.createElement('div');
-            headerTitle.className = 'cd-header-title';
-            headerTitle.innerHTML = `<span>CapDebug</span>`;
-            this.titleCountSpan = document.createElement('span');
-            this.titleCountSpan.style.color = 'var(--cd-text-muted)';
-            this.titleCountSpan.style.fontSize = '11px';
-            this.titleCountSpan.textContent = '(0)';
-            headerTitle.appendChild(this.titleCountSpan);
-            headerLeft.appendChild(this.statusIndicator);
-            headerLeft.appendChild(headerTitle);
-            const headerActions = document.createElement('div');
-            headerActions.className = 'cd-header-actions';
-            // Pause/Resume Button
-            this.pauseBtn = document.createElement('button');
-            this.pauseBtn.className = 'cd-btn-icon';
-            this.pauseBtn.title = 'Pause/Resume capture';
-            this.pauseBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="6" y="4" width="4" height="16"/><rect x="14" y="4" width="4" height="16"/></svg>`;
-            this.pauseBtn.addEventListener('click', () => {
-                const isPaused = this.store.togglePause();
-                this.updatePauseState(isPaused);
-            });
-            // Clear Button
-            const clearBtn = document.createElement('button');
-            clearBtn.className = 'cd-btn-icon';
-            clearBtn.title = 'Clear events';
-            clearBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><line x1="4.93" y1="4.93" x2="19.07" y2="19.07"/></svg>`;
-            clearBtn.addEventListener('click', () => {
-                this.store.clear();
-                this.closeDetail();
-            });
-            // Export Button
-            const exportBtn = document.createElement('button');
-            exportBtn.className = 'cd-btn-icon';
-            exportBtn.title = 'Export JSON to clipboard';
-            exportBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>`;
-            exportBtn.addEventListener('click', async () => {
-                const json = this.store.exportJson();
-                await JsonViewer.copyToClipboard(json, exportBtn);
-            });
-            // Close Button
-            const closeBtn = document.createElement('button');
-            closeBtn.className = 'cd-btn-icon';
-            closeBtn.title = 'Close viewer';
-            closeBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>`;
-            closeBtn.addEventListener('click', () => this.close());
-            headerActions.appendChild(this.pauseBtn);
-            headerActions.appendChild(clearBtn);
-            headerActions.appendChild(exportBtn);
-            headerActions.appendChild(closeBtn);
-            header.appendChild(headerLeft);
-            header.appendChild(headerActions);
-            this.element.appendChild(header);
-            // 2. Tabs Bar
-            const tabsBar = document.createElement('div');
-            tabsBar.className = 'cd-tabs-bar';
-            const tabs = [
-                { id: 'all', label: 'All' },
-                { id: 'console', label: 'Console' },
-                { id: 'errors', label: 'Errors' },
-                { id: 'events', label: 'Events' },
-                { id: 'native', label: 'Native' },
-                { id: 'device', label: 'Device' },
-                { id: 'network', label: 'Network' },
-                { id: 'bridge', label: 'Bridge' },
-            ];
-            for (const { id, label } of tabs) {
-                const tabBtn = document.createElement('button');
-                tabBtn.className = 'cd-tab';
-                if (id === this.options.defaultTab) {
-                    tabBtn.classList.add('active');
-                }
-                const labelSpan = document.createElement('span');
-                labelSpan.textContent = label;
-                const badgeSpan = document.createElement('span');
-                badgeSpan.className = 'cd-tab-badge';
-                badgeSpan.textContent = '0';
-                tabBtn.appendChild(labelSpan);
-                tabBtn.appendChild(badgeSpan);
-                tabBtn.addEventListener('click', () => {
-                    this.selectTab(id);
-                });
-                this.tabElements.set(id, tabBtn);
-                this.tabBadgeElements.set(id, badgeSpan);
-                tabsBar.appendChild(tabBtn);
-            }
-            this.element.appendChild(tabsBar);
-            // 3. Toolbar (Search & Level Filters)
-            const toolbar = document.createElement('div');
-            toolbar.className = 'cd-toolbar';
-            this.searchInput = document.createElement('input');
-            this.searchInput.className = 'cd-search-input';
-            this.searchInput.type = 'text';
-            this.searchInput.placeholder = 'Filter logs, types, payloads...';
-            this.searchInput.addEventListener('input', () => {
-                this.store.setFilter({ search: this.searchInput.value });
-            });
-            const levelFilters = document.createElement('div');
-            levelFilters.className = 'cd-level-filters';
-            const levels = ['all', 'error', 'warn', 'info', 'debug'];
-            for (const lvl of levels) {
-                const pill = document.createElement('button');
-                pill.className = 'cd-level-pill';
-                pill.setAttribute('data-level', lvl);
-                pill.textContent = lvl === 'all' ? 'All' : lvl.toUpperCase();
-                if (lvl === 'all')
-                    pill.classList.add('active');
-                pill.addEventListener('click', () => {
-                    this.selectLevel(lvl);
-                });
-                this.levelPills.set(lvl, pill);
-                levelFilters.appendChild(pill);
-            }
-            toolbar.appendChild(this.searchInput);
-            toolbar.appendChild(levelFilters);
-            this.element.appendChild(toolbar);
-            // 4. Content Area
-            this.contentContainer = document.createElement('div');
-            this.contentContainer.className = 'cd-content';
-            this.eventListContainer = document.createElement('div');
-            this.eventListContainer.className = 'cd-event-list';
-            this.deviceViewContainer = document.createElement('div');
-            this.deviceViewContainer.className = 'cd-device-view';
-            this.deviceViewContainer.style.display = 'none';
-            this.contentContainer.appendChild(this.eventListContainer);
-            this.contentContainer.appendChild(this.deviceViewContainer);
-            this.element.appendChild(this.contentContainer);
-            // 5. Detail Overlay
-            this.buildDetailOverlay();
-        }
-        selectTab(tab) {
-            for (const [id, el] of this.tabElements.entries()) {
-                el.classList.toggle('active', id === tab);
-            }
-            this.store.setFilter({ tab });
-            this.closeDetail();
-            if (tab === 'device') {
-                this.eventListContainer.style.display = 'none';
-                this.deviceViewContainer.style.display = 'flex';
-                this.loadDeviceDiagnostics();
-            }
-            else {
-                this.eventListContainer.style.display = 'flex';
-                this.deviceViewContainer.style.display = 'none';
-            }
-        }
-        selectLevel(level) {
-            for (const [lvl, pill] of this.levelPills.entries()) {
-                pill.classList.toggle('active', lvl === level);
-            }
-            this.store.setFilter({ level });
-        }
-        updatePauseState(isPaused) {
-            this.statusIndicator.classList.toggle('paused', isPaused);
-            this.pauseBtn.classList.toggle('active', isPaused);
-            this.pauseBtn.title = isPaused ? 'Resume capture' : 'Pause capture';
-        }
-        bindStore() {
-            this.store.subscribe((events, store) => {
-                this.renderEventList(events);
-                this.renderCounts(store.getCounts());
-                this.updatePauseState(store.isPaused());
-            });
-        }
-        renderCounts(counts) {
-            this.titleCountSpan.textContent = `(${counts.all})`;
-            for (const [tab, badge] of this.tabBadgeElements.entries()) {
-                if (tab === 'device') {
-                    badge.style.display = 'none';
-                }
-                else {
-                    const count = counts[tab] || 0;
-                    badge.textContent = count > 999 ? '999+' : String(count);
-                }
-            }
-        }
-        renderEventList(events) {
-            if (this.store.getFilter().tab === 'device') {
-                return;
-            }
-            this.eventListContainer.innerHTML = '';
-            if (events.length === 0) {
-                const empty = document.createElement('div');
-                empty.className = 'cd-empty-state';
-                empty.innerHTML = `
+  const CapDebugNative = core.registerPlugin("CapDebug", {
+    web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.CapDebugWeb())
+  });
+
+  class DebugPanel {
+    element;
+    backdrop;
+    store;
+    options;
+    isOpen = false;
+    // Header UI
+    statusIndicator;
+    titleCountSpan;
+    pauseBtn;
+    // Tab elements
+    tabElements = /* @__PURE__ */ new Map();
+    tabBadgeElements = /* @__PURE__ */ new Map();
+    // Search & Filter UI
+    searchInput;
+    levelPills = /* @__PURE__ */ new Map();
+    // Content
+    contentContainer;
+    eventListContainer;
+    deviceViewContainer;
+    // Detail Overlay
+    detailOverlay;
+    selectedEvent = null;
+    // Device tab state
+    isDeviceLoading = false;
+    deviceData = null;
+    constructor(store, options = {}) {
+      this.store = store;
+      this.options = {
+        defaultTab: "all",
+        ...options
+      };
+      this.backdrop = document.createElement("div");
+      this.backdrop.className = "cd-backdrop";
+      this.element = document.createElement("div");
+      this.element.className = "cd-panel";
+      this.buildUI();
+      this.bindStore();
+      if (this.options.defaultTab) {
+        this.store.setFilter({ tab: this.options.defaultTab });
+      }
+    }
+    getElement() {
+      return this.element;
+    }
+    getBackdrop() {
+      return this.backdrop;
+    }
+    open() {
+      this.isOpen = true;
+      this.element.classList.add("open");
+      this.backdrop.classList.add("open");
+      if (this.store.getFilter().tab === "device") {
+        this.loadDeviceDiagnostics();
+      }
+    }
+    close() {
+      this.isOpen = false;
+      this.element.classList.remove("open");
+      this.backdrop.classList.remove("open");
+      this.closeDetail();
+      if (this.options.onClose) {
+        this.options.onClose();
+      }
+    }
+    toggle() {
+      if (this.isOpen) {
+        this.close();
+        return false;
+      } else {
+        this.open();
+        return true;
+      }
+    }
+    isPanelOpen() {
+      return this.isOpen;
+    }
+    buildUI() {
+      this.backdrop.addEventListener("click", () => this.close());
+      const header = document.createElement("div");
+      header.className = "cd-header";
+      const headerLeft = document.createElement("div");
+      headerLeft.className = "cd-header-left";
+      this.statusIndicator = document.createElement("div");
+      this.statusIndicator.className = "cd-status-indicator";
+      this.statusIndicator.title = "CapDebug Active";
+      const headerTitle = document.createElement("div");
+      headerTitle.className = "cd-header-title";
+      headerTitle.innerHTML = `<span>CapDebug</span>`;
+      this.titleCountSpan = document.createElement("span");
+      this.titleCountSpan.style.color = "var(--cd-text-muted)";
+      this.titleCountSpan.style.fontSize = "11px";
+      this.titleCountSpan.textContent = "(0)";
+      headerTitle.appendChild(this.titleCountSpan);
+      headerLeft.appendChild(this.statusIndicator);
+      headerLeft.appendChild(headerTitle);
+      const headerActions = document.createElement("div");
+      headerActions.className = "cd-header-actions";
+      this.pauseBtn = document.createElement("button");
+      this.pauseBtn.className = "cd-btn-icon";
+      this.pauseBtn.title = "Pause/Resume capture";
+      this.pauseBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="6" y="4" width="4" height="16"/><rect x="14" y="4" width="4" height="16"/></svg>`;
+      this.pauseBtn.addEventListener("click", () => {
+        const isPaused = this.store.togglePause();
+        this.updatePauseState(isPaused);
+      });
+      const clearBtn = document.createElement("button");
+      clearBtn.className = "cd-btn-icon";
+      clearBtn.title = "Clear events";
+      clearBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><line x1="4.93" y1="4.93" x2="19.07" y2="19.07"/></svg>`;
+      clearBtn.addEventListener("click", () => {
+        this.store.clear();
+        this.closeDetail();
+      });
+      const exportBtn = document.createElement("button");
+      exportBtn.className = "cd-btn-icon";
+      exportBtn.title = "Export JSON to clipboard";
+      exportBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>`;
+      exportBtn.addEventListener("click", async () => {
+        const json = this.store.exportJson();
+        await JsonViewer.copyToClipboard(json, exportBtn);
+      });
+      const closeBtn = document.createElement("button");
+      closeBtn.className = "cd-btn-icon";
+      closeBtn.title = "Close viewer";
+      closeBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>`;
+      closeBtn.addEventListener("click", () => this.close());
+      headerActions.appendChild(this.pauseBtn);
+      headerActions.appendChild(clearBtn);
+      headerActions.appendChild(exportBtn);
+      headerActions.appendChild(closeBtn);
+      header.appendChild(headerLeft);
+      header.appendChild(headerActions);
+      this.element.appendChild(header);
+      const tabsBar = document.createElement("div");
+      tabsBar.className = "cd-tabs-bar";
+      const tabs = [
+        { id: "all", label: "All" },
+        { id: "console", label: "Console" },
+        { id: "errors", label: "Errors" },
+        { id: "events", label: "Events" },
+        { id: "native", label: "Native" },
+        { id: "device", label: "Device" },
+        { id: "network", label: "Network" },
+        { id: "bridge", label: "Bridge" }
+      ];
+      for (const { id, label } of tabs) {
+        const tabBtn = document.createElement("button");
+        tabBtn.className = "cd-tab";
+        if (id === this.options.defaultTab) {
+          tabBtn.classList.add("active");
+        }
+        const labelSpan = document.createElement("span");
+        labelSpan.textContent = label;
+        const badgeSpan = document.createElement("span");
+        badgeSpan.className = "cd-tab-badge";
+        badgeSpan.textContent = "0";
+        tabBtn.appendChild(labelSpan);
+        tabBtn.appendChild(badgeSpan);
+        tabBtn.addEventListener("click", () => {
+          this.selectTab(id);
+        });
+        this.tabElements.set(id, tabBtn);
+        this.tabBadgeElements.set(id, badgeSpan);
+        tabsBar.appendChild(tabBtn);
+      }
+      this.element.appendChild(tabsBar);
+      const toolbar = document.createElement("div");
+      toolbar.className = "cd-toolbar";
+      this.searchInput = document.createElement("input");
+      this.searchInput.className = "cd-search-input";
+      this.searchInput.type = "text";
+      this.searchInput.placeholder = "Filter logs, types, payloads...";
+      this.searchInput.addEventListener("input", () => {
+        this.store.setFilter({ search: this.searchInput.value });
+      });
+      const levelFilters = document.createElement("div");
+      levelFilters.className = "cd-level-filters";
+      const levels = ["all", "error", "warn", "info", "debug"];
+      for (const lvl of levels) {
+        const pill = document.createElement("button");
+        pill.className = "cd-level-pill";
+        pill.setAttribute("data-level", lvl);
+        pill.textContent = lvl === "all" ? "All" : lvl.toUpperCase();
+        if (lvl === "all") pill.classList.add("active");
+        pill.addEventListener("click", () => {
+          this.selectLevel(lvl);
+        });
+        this.levelPills.set(lvl, pill);
+        levelFilters.appendChild(pill);
+      }
+      toolbar.appendChild(this.searchInput);
+      toolbar.appendChild(levelFilters);
+      this.element.appendChild(toolbar);
+      this.contentContainer = document.createElement("div");
+      this.contentContainer.className = "cd-content";
+      this.eventListContainer = document.createElement("div");
+      this.eventListContainer.className = "cd-event-list";
+      this.deviceViewContainer = document.createElement("div");
+      this.deviceViewContainer.className = "cd-device-view";
+      this.deviceViewContainer.style.display = "none";
+      this.contentContainer.appendChild(this.eventListContainer);
+      this.contentContainer.appendChild(this.deviceViewContainer);
+      this.element.appendChild(this.contentContainer);
+      this.buildDetailOverlay();
+    }
+    selectTab(tab) {
+      for (const [id, el] of this.tabElements.entries()) {
+        el.classList.toggle("active", id === tab);
+      }
+      this.store.setFilter({ tab });
+      this.closeDetail();
+      if (tab === "device") {
+        this.eventListContainer.style.display = "none";
+        this.deviceViewContainer.style.display = "flex";
+        this.loadDeviceDiagnostics();
+      } else {
+        this.eventListContainer.style.display = "flex";
+        this.deviceViewContainer.style.display = "none";
+      }
+    }
+    selectLevel(level) {
+      for (const [lvl, pill] of this.levelPills.entries()) {
+        pill.classList.toggle("active", lvl === level);
+      }
+      this.store.setFilter({ level });
+    }
+    updatePauseState(isPaused) {
+      this.statusIndicator.classList.toggle("paused", isPaused);
+      this.pauseBtn.classList.toggle("active", isPaused);
+      this.pauseBtn.title = isPaused ? "Resume capture" : "Pause capture";
+    }
+    bindStore() {
+      this.store.subscribe((events, store) => {
+        this.renderEventList(events);
+        this.renderCounts(store.getCounts());
+        this.updatePauseState(store.isPaused());
+      });
+    }
+    renderCounts(counts) {
+      this.titleCountSpan.textContent = `(${counts.all})`;
+      for (const [tab, badge] of this.tabBadgeElements.entries()) {
+        if (tab === "device") {
+          badge.style.display = "none";
+        } else {
+          const count = counts[tab] || 0;
+          badge.textContent = count > 999 ? "999+" : String(count);
+        }
+      }
+    }
+    renderEventList(events) {
+      if (this.store.getFilter().tab === "device") {
+        return;
+      }
+      this.eventListContainer.innerHTML = "";
+      if (events.length === 0) {
+        const empty = document.createElement("div");
+        empty.className = "cd-empty-state";
+        empty.innerHTML = `
         <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
         <span>No events match current filter</span>
       `;
-                this.eventListContainer.appendChild(empty);
-                return;
-            }
-            // Render newest items at the top
-            for (let i = events.length - 1; i >= 0; i--) {
-                const event = events[i];
-                const row = this.createEventRow(event);
-                this.eventListContainer.appendChild(row);
-            }
-        }
-        createEventRow(event) {
-            const row = document.createElement('div');
-            row.className = 'cd-event-row';
-            row.setAttribute('data-level', event.level || 'info');
-            const dot = document.createElement('div');
-            dot.className = 'cd-event-level-dot';
-            const time = document.createElement('div');
-            time.className = 'cd-event-time';
-            time.textContent = this.formatTime(event.timestamp);
-            const source = document.createElement('div');
-            source.className = 'cd-event-source';
-            source.textContent = event.source;
-            const main = document.createElement('div');
-            main.className = 'cd-event-main';
-            const type = document.createElement('div');
-            type.className = 'cd-event-type';
-            type.textContent = event.type;
-            main.appendChild(type);
-            if (event.message) {
-                const msg = document.createElement('div');
-                msg.className = 'cd-event-msg';
-                msg.textContent = event.message;
-                main.appendChild(msg);
-            }
-            row.appendChild(dot);
-            row.appendChild(time);
-            row.appendChild(source);
-            row.appendChild(main);
-            if (event.duration !== undefined) {
-                const duration = document.createElement('div');
-                duration.className = 'cd-event-duration';
-                duration.textContent = `${event.duration}ms`;
-                row.appendChild(duration);
-            }
-            row.addEventListener('click', () => {
-                this.showDetail(event);
-            });
-            return row;
-        }
-        buildDetailOverlay() {
-            this.detailOverlay = document.createElement('div');
-            this.detailOverlay.className = 'cd-detail-overlay';
-            const header = document.createElement('div');
-            header.className = 'cd-detail-header';
-            const backBtn = document.createElement('button');
-            backBtn.className = 'cd-detail-back';
-            backBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="19" y1="12" x2="5" y2="12"/><polyline points="12 19 5 12 12 5"/></svg> Back`;
-            backBtn.addEventListener('click', () => this.closeDetail());
-            const copyAllBtn = document.createElement('button');
-            copyAllBtn.className = 'cd-copy-btn-sm';
-            copyAllBtn.textContent = 'Copy JSON';
-            copyAllBtn.addEventListener('click', async () => {
-                if (this.selectedEvent) {
-                    await JsonViewer.copyToClipboard(JSON.stringify(this.selectedEvent, null, 2), copyAllBtn);
-                }
-            });
-            header.appendChild(backBtn);
-            header.appendChild(copyAllBtn);
-            this.detailOverlay.appendChild(header);
-            const body = document.createElement('div');
-            body.className = 'cd-detail-body';
-            this.detailOverlay.appendChild(body);
-            this.contentContainer.appendChild(this.detailOverlay);
-        }
-        showDetail(event) {
-            this.selectedEvent = event;
-            const body = this.detailOverlay.querySelector('.cd-detail-body');
-            body.innerHTML = '';
-            // 1. Meta Grid
-            const metaGrid = document.createElement('div');
-            metaGrid.className = 'cd-meta-grid';
-            const addMeta = (label, value) => {
-                if (value === undefined)
-                    return;
-                const item = document.createElement('div');
-                item.className = 'cd-meta-item';
-                item.innerHTML = `
+        this.eventListContainer.appendChild(empty);
+        return;
+      }
+      for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        const row = this.createEventRow(event);
+        this.eventListContainer.appendChild(row);
+      }
+    }
+    createEventRow(event) {
+      const row = document.createElement("div");
+      row.className = "cd-event-row";
+      row.setAttribute("data-level", event.level || "info");
+      const dot = document.createElement("div");
+      dot.className = "cd-event-level-dot";
+      const time = document.createElement("div");
+      time.className = "cd-event-time";
+      time.textContent = this.formatTime(event.timestamp);
+      const source = document.createElement("div");
+      source.className = "cd-event-source";
+      source.textContent = event.source;
+      const main = document.createElement("div");
+      main.className = "cd-event-main";
+      const type = document.createElement("div");
+      type.className = "cd-event-type";
+      type.textContent = event.type;
+      main.appendChild(type);
+      if (event.message) {
+        const msg = document.createElement("div");
+        msg.className = "cd-event-msg";
+        msg.textContent = event.message;
+        main.appendChild(msg);
+      }
+      row.appendChild(dot);
+      row.appendChild(time);
+      row.appendChild(source);
+      row.appendChild(main);
+      if (event.duration !== void 0) {
+        const duration = document.createElement("div");
+        duration.className = "cd-event-duration";
+        duration.textContent = `${event.duration}ms`;
+        row.appendChild(duration);
+      }
+      row.addEventListener("click", () => {
+        this.showDetail(event);
+      });
+      return row;
+    }
+    buildDetailOverlay() {
+      this.detailOverlay = document.createElement("div");
+      this.detailOverlay.className = "cd-detail-overlay";
+      const header = document.createElement("div");
+      header.className = "cd-detail-header";
+      const backBtn = document.createElement("button");
+      backBtn.className = "cd-detail-back";
+      backBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="19" y1="12" x2="5" y2="12"/><polyline points="12 19 5 12 12 5"/></svg> Back`;
+      backBtn.addEventListener("click", () => this.closeDetail());
+      const copyAllBtn = document.createElement("button");
+      copyAllBtn.className = "cd-copy-btn-sm";
+      copyAllBtn.textContent = "Copy JSON";
+      copyAllBtn.addEventListener("click", async () => {
+        if (this.selectedEvent) {
+          await JsonViewer.copyToClipboard(
+            JSON.stringify(this.selectedEvent, null, 2),
+            copyAllBtn
+          );
+        }
+      });
+      header.appendChild(backBtn);
+      header.appendChild(copyAllBtn);
+      this.detailOverlay.appendChild(header);
+      const body = document.createElement("div");
+      body.className = "cd-detail-body";
+      this.detailOverlay.appendChild(body);
+      this.contentContainer.appendChild(this.detailOverlay);
+    }
+    showDetail(event) {
+      this.selectedEvent = event;
+      const body = this.detailOverlay.querySelector(".cd-detail-body");
+      body.innerHTML = "";
+      const metaGrid = document.createElement("div");
+      metaGrid.className = "cd-meta-grid";
+      const addMeta = (label, value) => {
+        if (value === void 0) return;
+        const item = document.createElement("div");
+        item.className = "cd-meta-item";
+        item.innerHTML = `
         <span class="cd-meta-label">${label}</span>
         <span class="cd-meta-val">${value}</span>
       `;
-                metaGrid.appendChild(item);
-            };
-            addMeta('Type', event.type);
-            addMeta('Source', event.source);
-            addMeta('Level', event.level);
-            addMeta('Time', `${this.formatTime(event.timestamp)} (${new Date(event.timestamp).toLocaleTimeString()})`);
-            addMeta('ID', event.id);
-            if (event.duration !== undefined)
-                addMeta('Duration', `${event.duration}ms`);
-            if (event.platform)
-                addMeta('Platform', event.platform);
-            body.appendChild(metaGrid);
-            // 2. Message
-            if (event.message) {
-                const msgSection = document.createElement('div');
-                msgSection.innerHTML = `<div class="cd-section-title">Message</div>`;
-                const msgBlock = document.createElement('div');
-                msgBlock.className = 'cd-msg-block';
-                msgBlock.textContent = event.message;
-                msgSection.appendChild(msgBlock);
-                body.appendChild(msgSection);
-            }
-            // 3. Data Payload / JSON Viewer
-            if (event.data !== undefined) {
-                const dataSection = document.createElement('div');
-                dataSection.innerHTML = `<div class="cd-section-title">Data Payload</div>`;
-                const jsonTree = JsonViewer.render(event.data, 3);
-                dataSection.appendChild(jsonTree);
-                body.appendChild(dataSection);
-            }
-            this.detailOverlay.classList.add('open');
-        }
-        closeDetail() {
-            this.selectedEvent = null;
-            this.detailOverlay.classList.remove('open');
-        }
-        async loadDeviceDiagnostics() {
-            if (this.isDeviceLoading)
-                return;
-            this.isDeviceLoading = true;
-            this.deviceViewContainer.innerHTML = `
+        metaGrid.appendChild(item);
+      };
+      addMeta("Type", event.type);
+      addMeta("Source", event.source);
+      addMeta("Level", event.level);
+      addMeta("Time", `${this.formatTime(event.timestamp)} (${new Date(event.timestamp).toLocaleTimeString()})`);
+      addMeta("ID", event.id);
+      if (event.duration !== void 0) addMeta("Duration", `${event.duration}ms`);
+      if (event.platform) addMeta("Platform", event.platform);
+      body.appendChild(metaGrid);
+      if (event.message) {
+        const msgSection = document.createElement("div");
+        msgSection.innerHTML = `<div class="cd-section-title">Message</div>`;
+        const msgBlock = document.createElement("div");
+        msgBlock.className = "cd-msg-block";
+        msgBlock.textContent = event.message;
+        msgSection.appendChild(msgBlock);
+        body.appendChild(msgSection);
+      }
+      if (event.data !== void 0) {
+        const dataSection = document.createElement("div");
+        dataSection.innerHTML = `<div class="cd-section-title">Data Payload</div>`;
+        const jsonTree = JsonViewer.render(event.data, 3);
+        dataSection.appendChild(jsonTree);
+        body.appendChild(dataSection);
+      }
+      this.detailOverlay.classList.add("open");
+    }
+    closeDetail() {
+      this.selectedEvent = null;
+      this.detailOverlay.classList.remove("open");
+    }
+    async loadDeviceDiagnostics() {
+      if (this.isDeviceLoading) return;
+      this.isDeviceLoading = true;
+      this.deviceViewContainer.innerHTML = `
       <div class="cd-empty-state">
         <span>Querying native device diagnostics...</span>
       </div>
     `;
-            try {
-                const [device, memory, webView, app, network] = await Promise.allSettled([
-                    CapDebugNative.getDeviceInfo(),
-                    CapDebugNative.getMemoryInfo(),
-                    CapDebugNative.getWebViewInfo(),
-                    CapDebugNative.getAppInfo(),
-                    CapDebugNative.getNetworkInfo(),
-                ]);
-                this.deviceData = {
-                    device: device.status === 'fulfilled' ? device.value : { error: String(device.reason) },
-                    memory: memory.status === 'fulfilled' ? memory.value : { error: String(memory.reason) },
-                    webView: webView.status === 'fulfilled' ? webView.value : { error: String(webView.reason) },
-                    app: app.status === 'fulfilled' ? app.value : { error: String(app.reason) },
-                    network: network.status === 'fulfilled' ? network.value : { error: String(network.reason) },
-                };
-                // Emit native diagnostics event into the store as well
-                this.store.add({
-                    source: 'native',
-                    type: 'device.diagnostics',
-                    level: 'info',
-                    message: 'Device diagnostics loaded',
-                    data: this.deviceData,
-                });
-                this.renderDeviceView();
-            }
-            catch (err) {
-                this.deviceViewContainer.innerHTML = `
+      try {
+        const [device, memory, webView, app, network] = await Promise.allSettled([
+          CapDebugNative.getDeviceInfo(),
+          CapDebugNative.getMemoryInfo(),
+          CapDebugNative.getWebViewInfo(),
+          CapDebugNative.getAppInfo(),
+          CapDebugNative.getNetworkInfo()
+        ]);
+        this.deviceData = {
+          device: device.status === "fulfilled" ? device.value : { error: String(device.reason) },
+          memory: memory.status === "fulfilled" ? memory.value : { error: String(memory.reason) },
+          webView: webView.status === "fulfilled" ? webView.value : { error: String(webView.reason) },
+          app: app.status === "fulfilled" ? app.value : { error: String(app.reason) },
+          network: network.status === "fulfilled" ? network.value : { error: String(network.reason) }
+        };
+        this.store.add({
+          source: "native",
+          type: "device.diagnostics",
+          level: "info",
+          message: "Device diagnostics loaded",
+          data: this.deviceData
+        });
+        this.renderDeviceView();
+      } catch (err) {
+        this.deviceViewContainer.innerHTML = `
         <div class="cd-empty-state">
           <span style="color: var(--cd-color-error)">Failed to load diagnostics: ${err?.message || String(err)}</span>
         </div>
       `;
-            }
-            finally {
-                this.isDeviceLoading = false;
-            }
-        }
-        renderDeviceView() {
-            if (!this.deviceData)
-                return;
-            this.deviceViewContainer.innerHTML = '';
-            // Refresh action bar
-            const topBar = document.createElement('div');
-            topBar.style.display = 'flex';
-            topBar.style.justifyContent = 'space-between';
-            topBar.style.alignItems = 'center';
-            const infoLabel = document.createElement('span');
-            infoLabel.style.fontSize = '11px';
-            infoLabel.style.color = 'var(--cd-text-muted)';
-            infoLabel.textContent = `Diagnostic snapshot: ${new Date().toLocaleTimeString()}`;
-            const refreshBtn = document.createElement('button');
-            refreshBtn.className = 'cd-copy-btn-sm';
-            refreshBtn.textContent = '↻ Refresh Live Data';
-            refreshBtn.addEventListener('click', () => this.loadDeviceDiagnostics());
-            topBar.appendChild(infoLabel);
-            topBar.appendChild(refreshBtn);
-            this.deviceViewContainer.appendChild(topBar);
-            const sections = [
-                { title: 'Device Information', data: this.deviceData.device },
-                { title: 'Memory & Heap', data: this.deviceData.memory },
-                { title: 'Application Info', data: this.deviceData.app },
-                { title: 'WebView & User Agent', data: this.deviceData.webView },
-                { title: 'Network State', data: this.deviceData.network },
-            ];
-            for (const { title, data } of sections) {
-                const card = document.createElement('div');
-                card.className = 'cd-device-card';
-                const cardHeader = document.createElement('div');
-                cardHeader.className = 'cd-device-card-header';
-                cardHeader.textContent = title;
-                card.appendChild(cardHeader);
-                if (typeof data === 'object' && data !== null) {
-                    const grid = document.createElement('div');
-                    grid.className = 'cd-device-grid';
-                    for (const [k, v] of Object.entries(data)) {
-                        if (typeof v === 'object' && v !== null)
-                            continue;
-                        const item = document.createElement('div');
-                        item.className = 'cd-meta-item';
-                        item.innerHTML = `
+      } finally {
+        this.isDeviceLoading = false;
+      }
+    }
+    renderDeviceView() {
+      if (!this.deviceData) return;
+      this.deviceViewContainer.innerHTML = "";
+      const topBar = document.createElement("div");
+      topBar.style.display = "flex";
+      topBar.style.justifyContent = "space-between";
+      topBar.style.alignItems = "center";
+      const infoLabel = document.createElement("span");
+      infoLabel.style.fontSize = "11px";
+      infoLabel.style.color = "var(--cd-text-muted)";
+      infoLabel.textContent = `Diagnostic snapshot: ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
+      const refreshBtn = document.createElement("button");
+      refreshBtn.className = "cd-copy-btn-sm";
+      refreshBtn.textContent = "\u21BB Refresh Live Data";
+      refreshBtn.addEventListener("click", () => this.loadDeviceDiagnostics());
+      topBar.appendChild(infoLabel);
+      topBar.appendChild(refreshBtn);
+      this.deviceViewContainer.appendChild(topBar);
+      const sections = [
+        { title: "Device Information", data: this.deviceData.device },
+        { title: "Memory & Heap", data: this.deviceData.memory },
+        { title: "Application Info", data: this.deviceData.app },
+        { title: "WebView & User Agent", data: this.deviceData.webView },
+        { title: "Network State", data: this.deviceData.network }
+      ];
+      for (const { title, data } of sections) {
+        const card = document.createElement("div");
+        card.className = "cd-device-card";
+        const cardHeader = document.createElement("div");
+        cardHeader.className = "cd-device-card-header";
+        cardHeader.textContent = title;
+        card.appendChild(cardHeader);
+        if (typeof data === "object" && data !== null) {
+          const grid = document.createElement("div");
+          grid.className = "cd-device-grid";
+          for (const [k, v] of Object.entries(data)) {
+            if (typeof v === "object" && v !== null) continue;
+            const item = document.createElement("div");
+            item.className = "cd-meta-item";
+            item.innerHTML = `
             <span class="cd-meta-label">${k}</span>
-            <span class="cd-meta-val">${v !== undefined && v !== null ? String(v) : '—'}</span>
+            <span class="cd-meta-val">${v !== void 0 && v !== null ? String(v) : "\u2014"}</span>
           `;
-                        grid.appendChild(item);
-                    }
-                    card.appendChild(grid);
-                    // Render nested objects if present
-                    for (const [k, v] of Object.entries(data)) {
-                        if (typeof v === 'object' && v !== null) {
-                            const nestedSection = document.createElement('div');
-                            nestedSection.innerHTML = `<div style="font-size: 10px; color: var(--cd-text-muted); font-weight: 600; margin-top: 6px;">${k.toUpperCase()}</div>`;
-                            nestedSection.appendChild(JsonViewer.render(v, 2));
-                            card.appendChild(nestedSection);
-                        }
-                    }
-                }
-                else {
-                    card.textContent = String(data);
-                }
-                this.deviceViewContainer.appendChild(card);
-            }
-        }
-        formatTime(timestamp) {
-            const d = new Date(timestamp);
-            const h = String(d.getHours()).padStart(2, '0');
-            const m = String(d.getMinutes()).padStart(2, '0');
-            const s = String(d.getSeconds()).padStart(2, '0');
-            const ms = String(d.getMilliseconds()).padStart(3, '0');
-            return `${h}:${m}:${s}.${ms}`;
-        }
-    }
-
-    class CapDebugViewerElement extends HTMLElement {
-        static TAG = 'cap-debug-viewer';
-        shadowRootNode;
-        floatingButton = null;
-        debugPanel = null;
-        store = null;
-        unsubscribeStore = null;
-        constructor() {
-            super();
-            this.shadowRootNode = this.attachShadow({ mode: 'open' });
-        }
-        getStore() {
-            return this.store;
-        }
-        init(store, options = {}) {
-            this.store = store;
-            // Inject isolated styles
-            const styleEl = document.createElement('style');
-            styleEl.textContent = VIEWER_STYLES;
-            this.shadowRootNode.appendChild(styleEl);
-            // Create Panel
-            this.debugPanel = new DebugPanel(store, {
-                defaultTab: options.defaultTab || 'all',
-                onClose: () => {
-                    // Can handle panel close events if needed
-                },
-            });
-            this.shadowRootNode.appendChild(this.debugPanel.getBackdrop());
-            this.shadowRootNode.appendChild(this.debugPanel.getElement());
-            // Create Floating Button (if enabled)
-            if (options.button !== false) {
-                this.floatingButton = new FloatingButton({
-                    position: options.position,
-                    persistPosition: options.persistPosition !== false,
-                    onClick: () => {
-                        this.toggle();
-                    },
-                });
-                this.shadowRootNode.appendChild(this.floatingButton.getElement());
-            }
-            // Subscribe to error counts for the button badge
-            this.unsubscribeStore = store.subscribe((_events, s) => {
-                const counts = s.getCounts();
-                if (this.floatingButton) {
-                    this.floatingButton.setErrorCount(counts.errors);
-                }
-            });
-        }
-        show() {
-            if (this.debugPanel) {
-                this.debugPanel.open();
-            }
-        }
-        hide() {
-            if (this.debugPanel) {
-                this.debugPanel.close();
-            }
-        }
-        toggle() {
-            if (this.debugPanel) {
-                return this.debugPanel.toggle();
-            }
-            return false;
-        }
-        showButton() {
-            if (this.floatingButton) {
-                this.floatingButton.show();
-            }
-        }
-        hideButton() {
-            if (this.floatingButton) {
-                this.floatingButton.hide();
-            }
-        }
-        disconnectedCallback() {
-            if (this.unsubscribeStore) {
-                this.unsubscribeStore();
-                this.unsubscribeStore = null;
-            }
-        }
+            grid.appendChild(item);
+          }
+          card.appendChild(grid);
+          for (const [k, v] of Object.entries(data)) {
+            if (typeof v === "object" && v !== null) {
+              const nestedSection = document.createElement("div");
+              nestedSection.innerHTML = `<div style="font-size: 10px; color: var(--cd-text-muted); font-weight: 600; margin-top: 6px;">${k.toUpperCase()}</div>`;
+              nestedSection.appendChild(JsonViewer.render(v, 2));
+              card.appendChild(nestedSection);
+            }
+          }
+        } else {
+          card.textContent = String(data);
+        }
+        this.deviceViewContainer.appendChild(card);
+      }
     }
-    function registerCustomElement() {
-        if (typeof customElements !== 'undefined' && !customElements.get(CapDebugViewerElement.TAG)) {
-            customElements.define(CapDebugViewerElement.TAG, CapDebugViewerElement);
-        }
-    }
-
-    class CapDebugManager {
-        store;
-        viewerElement = null;
-        isMounted = false;
-        customEventCollector;
-        consoleCollector;
-        errorCollector;
-        networkCollector;
-        browserEventCollector;
-        bridgeCollector;
-        constructor() {
-            this.store = new CapDebugStore();
-            this.customEventCollector = new CustomEventCollector(this.store);
-            this.consoleCollector = new ConsoleCollector();
-            this.errorCollector = new ErrorCollector();
-            this.networkCollector = new NetworkCollector();
-            this.browserEventCollector = new BrowserEventCollector();
-            this.bridgeCollector = new BridgeCollector();
-        }
-        get native() {
-            return CapDebugNative;
-        }
-        get currentStore() {
-            return this.store;
-        }
-        /**
-         * Mounts the CapDebug UI into the DOM and activates collectors.
-         */
-        mount(options = {}) {
-            if (typeof window === 'undefined' || typeof document === 'undefined') {
-                return;
-            }
-            if (this.isMounted) {
-                this.unmount();
-            }
-            // Configure store
-            if (options.maxEvents) {
-                this.store.setMaxEvents(options.maxEvents);
-            }
-            if (options.customMaskKeys) {
-                this.store.setCustomMaskKeys(options.customMaskKeys);
-            }
-            // 1. Start core CustomEvent bus listener
-            this.customEventCollector.start();
-            // 2. Start optional collectors
-            if (options.console !== false) {
-                this.consoleCollector.start();
-            }
-            if (options.errors !== false) {
-                this.errorCollector.start();
-            }
-            if (options.network) {
-                const netOpts = typeof options.network === 'object' ? options.network : {};
-                this.networkCollector.setOptions(netOpts);
-                this.networkCollector.start();
-            }
-            if (options.bridge) {
-                this.bridgeCollector.start();
-            }
-            this.browserEventCollector.start();
-            // 3. Register and create Web Component
-            registerCustomElement();
-            this.viewerElement = document.createElement(CapDebugViewerElement.TAG);
-            this.viewerElement.init(this.store, options);
-            document.body.appendChild(this.viewerElement);
-            this.isMounted = true;
-        }
-        /**
-         * Unmounts CapDebug UI and stops all collectors.
-         */
-        unmount() {
-            if (!this.isMounted)
-                return;
-            if (this.viewerElement && this.viewerElement.parentNode) {
-                this.viewerElement.parentNode.removeChild(this.viewerElement);
-                this.viewerElement = null;
-            }
-            this.customEventCollector.stop();
-            this.consoleCollector.stop();
-            this.errorCollector.stop();
-            this.networkCollector.stop();
-            this.browserEventCollector.stop();
-            this.bridgeCollector.stop();
-            this.isMounted = false;
-        }
-        /**
-         * Opens the debug viewer drawer.
-         */
-        show() {
-            if (this.viewerElement) {
-                this.viewerElement.show();
-            }
-        }
-        /**
-         * Closes the debug viewer drawer.
-         */
-        hide() {
-            if (this.viewerElement) {
-                this.viewerElement.hide();
-            }
-        }
-        /**
-         * Toggles the debug viewer drawer open/closed.
-         */
-        toggle() {
-            if (this.viewerElement) {
-                return this.viewerElement.toggle();
-            }
-            return false;
-        }
-        /**
-         * Dispatches a debug event through the CustomEvent bus.
-         */
-        emit(event) {
-            if (typeof window === 'undefined')
-                return;
-            window.dispatchEvent(new CustomEvent('capdebug', {
-                detail: {
-                    id: event.id,
-                    timestamp: event.timestamp || Date.now(),
-                    source: event.source || 'web',
-                    type: event.type,
-                    level: event.level || 'info',
-                    message: event.message,
-                    data: event.data,
-                    duration: event.duration,
-                    platform: event.platform,
-                },
-            }));
-        }
-        /**
-         * Clears all recorded events from the store.
-         */
-        clear() {
-            this.store.clear();
-        }
-        /**
-         * Pauses capturing new events.
-         */
-        pause() {
+    formatTime(timestamp) {
+      const d = new Date(timestamp);
+      const h = String(d.getHours()).padStart(2, "0");
+      const m = String(d.getMinutes()).padStart(2, "0");
+      const s = String(d.getSeconds()).padStart(2, "0");
+      const ms = String(d.getMilliseconds()).padStart(3, "0");
+      return `${h}:${m}:${s}.${ms}`;
+    }
+  }
+
+  class CapDebugViewerElement extends HTMLElement {
+    static TAG = "cap-debug-viewer";
+    shadowRootNode;
+    floatingButton = null;
+    debugPanel = null;
+    store = null;
+    unsubscribeStore = null;
+    constructor() {
+      super();
+      this.shadowRootNode = this.attachShadow({ mode: "open" });
+    }
+    getStore() {
+      return this.store;
+    }
+    init(store, options = {}) {
+      this.store = store;
+      const styleEl = document.createElement("style");
+      styleEl.textContent = VIEWER_STYLES;
+      this.shadowRootNode.appendChild(styleEl);
+      this.debugPanel = new DebugPanel(store, {
+        defaultTab: options.defaultTab || "all",
+        onClose: () => {
+        }
+      });
+      this.shadowRootNode.appendChild(this.debugPanel.getBackdrop());
+      this.shadowRootNode.appendChild(this.debugPanel.getElement());
+      if (options.button !== false) {
+        this.floatingButton = new FloatingButton({
+          position: options.position,
+          persistPosition: options.persistPosition !== false,
+          onClick: () => {
+            this.toggle();
+          }
+        });
+        this.shadowRootNode.appendChild(this.floatingButton.getElement());
+      }
+      this.unsubscribeStore = store.subscribe((_events, s) => {
+        const counts = s.getCounts();
+        if (this.floatingButton) {
+          this.floatingButton.setErrorCount(counts.errors);
+        }
+      });
+    }
+    show() {
+      if (this.debugPanel) {
+        this.debugPanel.open();
+      }
+    }
+    hide() {
+      if (this.debugPanel) {
+        this.debugPanel.close();
+      }
+    }
+    toggle() {
+      if (this.debugPanel) {
+        return this.debugPanel.toggle();
+      }
+      return false;
+    }
+    showButton() {
+      if (this.floatingButton) {
+        this.floatingButton.show();
+      }
+    }
+    hideButton() {
+      if (this.floatingButton) {
+        this.floatingButton.hide();
+      }
+    }
+    disconnectedCallback() {
+      if (this.unsubscribeStore) {
+        this.unsubscribeStore();
+        this.unsubscribeStore = null;
+      }
+    }
+  }
+  function registerCustomElement() {
+    if (typeof customElements !== "undefined" && !customElements.get(CapDebugViewerElement.TAG)) {
+      customElements.define(CapDebugViewerElement.TAG, CapDebugViewerElement);
+    }
+  }
+
+  class HttpSseSignalingClient {
+    baseUrl;
+    sessionId = "";
+    secret = "";
+    role = "peer";
+    eventSource = null;
+    listeners = /* @__PURE__ */ new Set();
+    isClosed = false;
+    pollTimer = null;
+    constructor(baseUrl) {
+      this.baseUrl = baseUrl.replace(/\/+$/, "");
+    }
+    async createSession(ttlSeconds = 300) {
+      this.role = "host";
+      const res = await fetch(`${this.baseUrl}/api/pair/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ttl: ttlSeconds })
+      });
+      if (!res.ok) {
+        throw new Error(`Failed to create pairing session: ${res.statusText}`);
+      }
+      const data = await res.json();
+      this.sessionId = data.sessionId;
+      this.secret = data.secret;
+      this.connectEventStream();
+      return data;
+    }
+    async joinSession(sessionId, secret) {
+      this.role = "peer";
+      this.sessionId = sessionId;
+      this.secret = secret;
+      const res = await fetch(`${this.baseUrl}/api/pair/join`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sessionId, secret })
+      });
+      if (!res.ok) {
+        const err = await res.text().catch(() => "");
+        throw new Error(`Failed to join pairing session: ${err || res.statusText}`);
+      }
+      this.connectEventStream();
+    }
+    async send(message) {
+      if (this.isClosed) return;
+      message.sessionId = this.sessionId;
+      message.secret = this.secret;
+      message.sender = this.role;
+      message.timestamp = Date.now();
+      await fetch(`${this.baseUrl}/api/pair/signal`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(message)
+      });
+    }
+    onMessage(callback) {
+      this.listeners.add(callback);
+      return () => {
+        this.listeners.delete(callback);
+      };
+    }
+    close() {
+      this.isClosed = true;
+      if (this.eventSource) {
+        this.eventSource.close();
+        this.eventSource = null;
+      }
+      if (this.pollTimer) {
+        clearInterval(this.pollTimer);
+        this.pollTimer = null;
+      }
+      this.listeners.clear();
+    }
+    connectEventStream() {
+      if (typeof EventSource !== "undefined") {
+        const sseUrl = `${this.baseUrl}/api/pair/events?session=${encodeURIComponent(this.sessionId)}&secret=${encodeURIComponent(this.secret)}&role=${this.role}`;
+        this.eventSource = new EventSource(sseUrl);
+        this.eventSource.onmessage = (event) => {
+          if (!event.data) return;
+          try {
+            const msg = JSON.parse(event.data);
+            this.dispatchMessage(msg);
+          } catch {
+          }
+        };
+        this.eventSource.onerror = () => {
+        };
+      } else {
+        this.startPolling();
+      }
+    }
+    startPolling() {
+      if (this.pollTimer) return;
+      this.pollTimer = setInterval(async () => {
+        if (this.isClosed || !this.sessionId) return;
+        try {
+          const res = await fetch(
+            `${this.baseUrl}/api/pair/poll?session=${encodeURIComponent(this.sessionId)}&secret=${encodeURIComponent(this.secret)}&role=${this.role}`
+          );
+          if (res.ok) {
+            const messages = await res.json();
+            if (Array.isArray(messages)) {
+              for (const msg of messages) {
+                this.dispatchMessage(msg);
+              }
+            }
+          }
+        } catch {
+        }
+      }, 1e3);
+    }
+    dispatchMessage(message) {
+      for (const listener of this.listeners) {
+        try {
+          listener(message);
+        } catch (err) {
+          console.error("[CapDebug Signaling] Listener error:", err);
+        }
+      }
+    }
+  }
+
+  const PROTOCOL_VERSION = 1;
+  class RemoteProtocol {
+    static createHello(capdebugVersion = "0.2.0", platform = "web", deviceName) {
+      return {
+        v: 1,
+        type: "hello",
+        payload: {
+          capdebugVersion,
+          platform,
+          deviceName: deviceName || (typeof navigator !== "undefined" ? navigator.userAgent : "Unknown Device")
+        },
+        timestamp: Date.now()
+      };
+    }
+    static createHelloAck() {
+      return {
+        v: 1,
+        type: "hello-ack",
+        payload: {
+          serverTime: Date.now()
+        },
+        timestamp: Date.now()
+      };
+    }
+    static createEvent(event) {
+      return {
+        v: 1,
+        type: "event",
+        event,
+        timestamp: Date.now()
+      };
+    }
+    static createBatch(events) {
+      return {
+        v: 1,
+        type: "events-batch",
+        events,
+        timestamp: Date.now()
+      };
+    }
+    static createControl(command) {
+      return {
+        v: 1,
+        type: "control",
+        command,
+        timestamp: Date.now()
+      };
+    }
+    static createPing(timestamp = Date.now()) {
+      return {
+        v: 1,
+        type: "ping",
+        timestamp
+      };
+    }
+    static createPong(pingTimestamp) {
+      return {
+        v: 1,
+        type: "pong",
+        payload: { pingTimestamp },
+        timestamp: Date.now()
+      };
+    }
+    static serialize(message) {
+      return JSON.stringify(message);
+    }
+    static parse(raw) {
+      try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+          return null;
+        }
+        if (parsed.v !== PROTOCOL_VERSION) {
+          console.warn(`[CapDebug Remote] Unsupported protocol version: ${parsed.v}`);
+          return null;
+        }
+        return parsed;
+      } catch {
+        return null;
+      }
+    }
+  }
+
+  class RemoteEventBuffer {
+    buffer = [];
+    maxCapacity;
+    droppedCount = 0;
+    constructor(maxCapacity = 100) {
+      this.maxCapacity = Math.max(1, maxCapacity);
+    }
+    push(event) {
+      if (this.buffer.length >= this.maxCapacity) {
+        this.buffer.shift();
+      }
+      this.buffer.push(event);
+    }
+    flush() {
+      const items = [...this.buffer];
+      this.buffer = [];
+      return items;
+    }
+    clear() {
+      this.buffer = [];
+      this.droppedCount = 0;
+    }
+    size() {
+      return this.buffer.length;
+    }
+    getDroppedCount() {
+      return this.droppedCount;
+    }
+    incrementDropped() {
+      this.droppedCount++;
+    }
+  }
+
+  class WebRTCTransport {
+    id = "webrtc";
+    pc = null;
+    signaling = null;
+    config = null;
+    eventsChannel = null;
+    controlChannel = null;
+    status = "disconnected";
+    buffer = new RemoteEventBuffer(100);
+    eventListeners = /* @__PURE__ */ new Set();
+    controlListeners = /* @__PURE__ */ new Set();
+    statusListeners = /* @__PURE__ */ new Set();
+    diagnosticsListeners = /* @__PURE__ */ new Set();
+    pingTimer = null;
+    statsTimer = null;
+    rttMs = 0;
+    totalEventsSent = 0;
+    totalEventsReceived = 0;
+    connectedAt = 0;
+    remoteDeviceName = "Unknown Device";
+    remotePlatform = "unknown";
+    diagnostics = {
+      transport: "webrtc",
+      status: "disconnected",
+      route: "unknown"
+    };
+    async connect(config) {
+      this.config = config;
+      this.setStatus("connecting");
+      const signalingUrl = config.signalingUrl || (typeof window !== "undefined" ? window.location.origin : "http://localhost:4783");
+      this.signaling = new HttpSseSignalingClient(signalingUrl);
+      this.signaling.onMessage((msg) => this.handleSignalingMessage(msg));
+      if (config.isHost) {
+        this.setStatus("signaling");
+      } else {
+        this.setStatus("signaling");
+        await this.signaling.joinSession(config.sessionId, config.secret);
+      }
+    }
+    send(event) {
+      if (this.eventsChannel && this.eventsChannel.readyState === "open") {
+        if (this.eventsChannel.bufferedAmount > 256 * 1024) {
+          if (event.level === "debug" || event.level === "info") {
+            this.buffer.incrementDropped();
+            return;
+          }
+        }
+        const msg = RemoteProtocol.createEvent(event);
+        try {
+          this.eventsChannel.send(RemoteProtocol.serialize(msg));
+          this.totalEventsSent++;
+        } catch (err) {
+          console.error("[CapDebug Remote] Send error:", err);
+        }
+      } else {
+        this.buffer.push(event);
+      }
+    }
+    sendControl(command) {
+      if (this.controlChannel && this.controlChannel.readyState === "open") {
+        const msg = RemoteProtocol.createControl(command);
+        try {
+          this.controlChannel.send(RemoteProtocol.serialize(msg));
+        } catch (err) {
+          console.error("[CapDebug Remote] Control send error:", err);
+        }
+      }
+    }
+    disconnect() {
+      this.stopTimers();
+      if (this.controlChannel) {
+        try {
+          this.sendControl({ type: "disconnect" });
+        } catch {
+        }
+      }
+      if (this.signaling) {
+        this.signaling.close();
+        this.signaling = null;
+      }
+      if (this.eventsChannel) {
+        this.eventsChannel.close();
+        this.eventsChannel = null;
+      }
+      if (this.controlChannel) {
+        this.controlChannel.close();
+        this.controlChannel = null;
+      }
+      if (this.pc) {
+        this.pc.close();
+        this.pc = null;
+      }
+      this.setStatus("disconnected");
+    }
+    getStatus() {
+      return this.status;
+    }
+    getDiagnostics() {
+      return {
+        ...this.diagnostics,
+        status: this.status,
+        rttMs: this.rttMs,
+        bufferedAmountBytes: this.eventsChannel?.bufferedAmount || 0,
+        droppedEventsCount: this.buffer.getDroppedCount(),
+        totalEventsSent: this.totalEventsSent,
+        totalEventsReceived: this.totalEventsReceived,
+        connectedAt: this.connectedAt,
+        deviceName: this.remoteDeviceName,
+        platform: this.remotePlatform
+      };
+    }
+    onEvent(callback) {
+      this.eventListeners.add(callback);
+      return () => this.eventListeners.delete(callback);
+    }
+    onControl(callback) {
+      this.controlListeners.add(callback);
+      return () => this.controlListeners.delete(callback);
+    }
+    onStatusChange(callback) {
+      this.statusListeners.add(callback);
+      callback(this.status);
+      return () => this.statusListeners.delete(callback);
+    }
+    onDiagnostics(callback) {
+      this.diagnosticsListeners.add(callback);
+      return () => this.diagnosticsListeners.delete(callback);
+    }
+    async handleSignalingMessage(msg) {
+      switch (msg.type) {
+        case "peer-joined":
+          if (this.config?.isHost) {
+            await this.startHandshakeAsInitiator();
+          }
+          break;
+        case "offer":
+          if (!this.config?.isHost) {
+            await this.handleOffer(msg.payload);
+          }
+          break;
+        case "answer":
+          if (this.config?.isHost && this.pc) {
+            await this.pc.setRemoteDescription(new RTCSessionDescription(msg.payload));
+          }
+          break;
+        case "ice-candidate":
+          if (this.pc && msg.payload) {
+            try {
+              await this.pc.addIceCandidate(new RTCIceCandidate(msg.payload));
+            } catch (err) {
+              console.warn("[CapDebug Remote] ICE Candidate error:", err);
+            }
+          }
+          break;
+        case "disconnect":
+          this.disconnect();
+          break;
+      }
+    }
+    initPeerConnection() {
+      const iceServers = this.config?.iceServers || [
+        { urls: "stun:stun.l.google.com:19302" },
+        { urls: "stun:global.stun.twilio.com:3478" }
+      ];
+      const pc = new RTCPeerConnection({ iceServers });
+      pc.onicecandidate = (event) => {
+        if (event.candidate && this.signaling) {
+          this.signaling.send({
+            sessionId: this.config.sessionId,
+            secret: this.config.secret,
+            type: "ice-candidate",
+            sender: this.config.isHost ? "host" : "peer",
+            payload: event.candidate.toJSON()
+          });
+        }
+      };
+      pc.onconnectionstatechange = () => {
+        this.updateDiagnostics();
+        if (pc.connectionState === "failed") {
+          this.setStatus("failed");
+        } else if (pc.connectionState === "closed" || pc.connectionState === "disconnected") {
+          this.setStatus("disconnected");
+        }
+      };
+      pc.oniceconnectionstatechange = () => {
+        this.updateDiagnostics();
+      };
+      this.pc = pc;
+      return pc;
+    }
+    async startHandshakeAsInitiator() {
+      const pc = this.initPeerConnection();
+      this.eventsChannel = pc.createDataChannel("events", { ordered: true });
+      this.controlChannel = pc.createDataChannel("control", { ordered: true });
+      this.setupDataChannel(this.eventsChannel, "events");
+      this.setupDataChannel(this.controlChannel, "control");
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      if (this.signaling) {
+        await this.signaling.send({
+          sessionId: this.config.sessionId,
+          secret: this.config.secret,
+          type: "offer",
+          sender: "host",
+          payload: offer
+        });
+      }
+    }
+    async handleOffer(offerSdp) {
+      const pc = this.initPeerConnection();
+      pc.ondatachannel = (event) => {
+        const channel = event.channel;
+        if (channel.label === "events") {
+          this.eventsChannel = channel;
+          this.setupDataChannel(channel, "events");
+        } else if (channel.label === "control") {
+          this.controlChannel = channel;
+          this.setupDataChannel(channel, "control");
+        }
+      };
+      await pc.setRemoteDescription(new RTCSessionDescription(offerSdp));
+      const answer = await pc.createAnswer();
+      await pc.setLocalDescription(answer);
+      if (this.signaling) {
+        await this.signaling.send({
+          sessionId: this.config.sessionId,
+          secret: this.config.secret,
+          type: "answer",
+          sender: "peer",
+          payload: answer
+        });
+      }
+    }
+    setupDataChannel(channel, label) {
+      channel.onopen = () => {
+        if (this.eventsChannel?.readyState === "open" && this.controlChannel?.readyState === "open") {
+          this.connectedAt = Date.now();
+          this.setStatus("connected");
+          this.startTimers();
+          if (!this.config?.isHost) {
+            const hello = RemoteProtocol.createHello("0.2.0", "mobile");
+            channel.send(RemoteProtocol.serialize(hello));
+            const buffered = this.buffer.flush();
+            if (buffered.length > 0 && this.eventsChannel?.readyState === "open") {
+              const batch = RemoteProtocol.createBatch(buffered);
+              this.eventsChannel.send(RemoteProtocol.serialize(batch));
+              this.totalEventsSent += buffered.length;
+            }
+          }
+        }
+      };
+      channel.onclose = () => {
+        this.setStatus("disconnected");
+      };
+      channel.onmessage = (e) => {
+        const raw = e.data;
+        if (typeof raw !== "string") return;
+        const message = RemoteProtocol.parse(raw);
+        if (!message) return;
+        if (label === "events") {
+          if (message.type === "event" && message.event) {
+            this.totalEventsReceived++;
+            for (const listener of this.eventListeners) {
+              listener(message.event);
+            }
+          } else if (message.type === "events-batch" && Array.isArray(message.events)) {
+            this.totalEventsReceived += message.events.length;
+            for (const ev of message.events) {
+              for (const listener of this.eventListeners) {
+                listener(ev);
+              }
+            }
+          }
+        } else if (label === "control") {
+          this.handleControlMessage(message);
+        }
+      };
+    }
+    handleControlMessage(message) {
+      if (message.type === "control" && message.command) {
+        for (const listener of this.controlListeners) {
+          listener(message.command);
+        }
+      } else if (message.type === "hello") {
+        this.remoteDeviceName = message.payload?.deviceName || "Mobile Device";
+        this.remotePlatform = message.payload?.platform || "mobile";
+        if (this.controlChannel?.readyState === "open") {
+          this.controlChannel.send(RemoteProtocol.serialize(RemoteProtocol.createHelloAck()));
+        }
+        this.updateDiagnostics();
+      } else if (message.type === "hello-ack") {
+        this.updateDiagnostics();
+      } else if (message.type === "ping") {
+        if (this.controlChannel?.readyState === "open") {
+          const pong = RemoteProtocol.createPong(message.timestamp || Date.now());
+          this.controlChannel.send(RemoteProtocol.serialize(pong));
+        }
+      } else if (message.type === "pong") {
+        const pingTime = message.payload?.pingTimestamp || message.timestamp;
+        if (pingTime) {
+          this.rttMs = Math.max(1, Date.now() - pingTime);
+          this.updateDiagnostics();
+        }
+      }
+    }
+    startTimers() {
+      this.stopTimers();
+      this.pingTimer = setInterval(() => {
+        if (this.controlChannel?.readyState === "open") {
+          this.controlChannel.send(RemoteProtocol.serialize(RemoteProtocol.createPing(Date.now())));
+        }
+      }, 2e3);
+      this.statsTimer = setInterval(() => {
+        this.queryWebRTCStats();
+      }, 3e3);
+    }
+    stopTimers() {
+      if (this.pingTimer) {
+        clearInterval(this.pingTimer);
+        this.pingTimer = null;
+      }
+      if (this.statsTimer) {
+        clearInterval(this.statsTimer);
+        this.statsTimer = null;
+      }
+    }
+    async queryWebRTCStats() {
+      if (!this.pc) return;
+      try {
+        const stats = await this.pc.getStats();
+        let candidateType = "unknown";
+        let protocol = "UDP";
+        let route = "unknown";
+        stats.forEach((report) => {
+          if (report.type === "candidate-pair" && (report.selected || report.state === "succeeded")) {
+            const localCandidate = stats.get(report.localCandidateId);
+            if (localCandidate) {
+              candidateType = localCandidate.candidateType || "host";
+              protocol = localCandidate.protocol || "UDP";
+              if (candidateType === "host") {
+                route = "direct / LAN";
+              } else if (candidateType === "srflx" || candidateType === "prflx") {
+                route = "STUN / WAN";
+              } else if (candidateType === "relay") {
+                route = "relay / TURN";
+              }
+            }
+            if (report.currentRoundTripTime) {
+              this.rttMs = Math.round(report.currentRoundTripTime * 1e3);
+            }
+          }
+        });
+        this.diagnostics = {
+          ...this.diagnostics,
+          candidateType,
+          protocol,
+          route
+        };
+        this.updateDiagnostics();
+      } catch {
+      }
+    }
+    setStatus(status) {
+      this.status = status;
+      this.updateDiagnostics();
+      for (const listener of this.statusListeners) {
+        listener(status);
+      }
+    }
+    updateDiagnostics() {
+      if (this.pc) {
+        this.diagnostics.connectionState = this.pc.connectionState;
+        this.diagnostics.iceConnectionState = this.pc.iceConnectionState;
+        this.diagnostics.iceGatheringState = this.pc.iceGatheringState;
+        this.diagnostics.signalingState = this.pc.signalingState;
+      }
+      const fullDiag = this.getDiagnostics();
+      for (const listener of this.diagnosticsListeners) {
+        listener(fullDiag);
+      }
+    }
+  }
+
+  class PairingHelper {
+    /**
+     * Creates a new pairing session with given TTL (default 5 minutes).
+     */
+    static createSession(ttlMs = 5 * 60 * 1e3) {
+      const now = Date.now();
+      return {
+        id: this.generateSessionId(),
+        createdAt: now,
+        expiresAt: now + ttlMs,
+        status: "waiting"
+      };
+    }
+    /**
+     * Generates a short, human-readable session ID (e.g. "K7P4-M2" or "7HQ2-9X").
+     */
+    static generateSessionId() {
+      const chars = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
+      const bytes = this.getRandomBytes(4);
+      let id = "";
+      for (let i = 0; i < 4; i++) {
+        id += chars[bytes[i] % chars.length];
+      }
+      const suffix = this.getRandomBytes(2);
+      id += "-" + chars[suffix[0] % chars.length] + chars[suffix[1] % chars.length];
+      return id;
+    }
+    /**
+     * Generates a cryptographically strong 128-bit random secret string.
+     */
+    static generateSecret() {
+      const bytes = this.getRandomBytes(16);
+      return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    /**
+     * Formats a web pairing URL where the secret is stored strictly in the URL fragment (#SECRET).
+     */
+    static formatPairingUrl(baseUrl, sessionId, secret) {
+      const cleanBase = baseUrl.replace(/\/+$/, "");
+      return `${cleanBase}/pair?s=${encodeURIComponent(sessionId)}#${secret}`;
+    }
+    /**
+     * Formats a Capacitor mobile deep link URL.
+     */
+    static formatDeepLinkUrl(sessionId, secret, signalingUrl) {
+      let url = `capdebug://pair?session=${encodeURIComponent(sessionId)}&secret=${encodeURIComponent(secret)}`;
+      if (signalingUrl) {
+        url += `&server=${encodeURIComponent(signalingUrl)}`;
+      }
+      return url;
+    }
+    /**
+     * Parses a web pairing URL or Capacitor deep-link URL into session and secret components.
+     */
+    static parseUrl(urlStr) {
+      if (!urlStr || typeof urlStr !== "string") return null;
+      try {
+        if (urlStr.startsWith("capdebug://")) {
+          const queryIdx = urlStr.indexOf("?");
+          if (queryIdx === -1) return null;
+          const search = urlStr.substring(queryIdx + 1);
+          const params = new URLSearchParams(search);
+          const sessionId2 = params.get("session") || params.get("s");
+          const secret2 = params.get("secret") || params.get("sec") || "";
+          const signalingUrl2 = params.get("server") || params.get("sig") || void 0;
+          if (sessionId2 && secret2) {
+            return { sessionId: sessionId2, secret: secret2, signalingUrl: signalingUrl2, rawUrl: urlStr };
+          }
+          return null;
+        }
+        const url = new URL(urlStr);
+        let sessionId = url.searchParams.get("s") || url.searchParams.get("session");
+        if (!sessionId && url.pathname.includes("/s/")) {
+          const parts = url.pathname.split("/s/");
+          if (parts[1]) {
+            sessionId = decodeURIComponent(parts[1].split("/")[0]);
+          }
+        }
+        let secret = url.hash.replace(/^#/, "");
+        if (!secret) {
+          secret = url.searchParams.get("secret") || url.searchParams.get("sec") || "";
+        }
+        const signalingUrl = url.searchParams.get("server") || `${url.protocol}//${url.host}`;
+        if (sessionId && secret) {
+          return {
+            sessionId: sessionId.trim(),
+            secret: secret.trim(),
+            signalingUrl,
+            rawUrl: urlStr
+          };
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    }
+    static getRandomBytes(length) {
+      const bytes = new Uint8Array(length);
+      if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+        crypto.getRandomValues(bytes);
+      } else {
+        for (let i = 0; i < length; i++) {
+          bytes[i] = Math.floor(Math.random() * 256);
+        }
+      }
+      return bytes;
+    }
+  }
+
+  class RemoteManager {
+    transport;
+    store;
+    isListening = false;
+    eventListener = null;
+    constructor(store) {
+      this.store = store;
+      this.transport = new WebRTCTransport();
+      this.setupControlHandler();
+    }
+    get activeTransport() {
+      return this.transport;
+    }
+    async connect(config) {
+      this.startEventListener();
+      await this.transport.connect(config);
+    }
+    disconnect() {
+      this.transport.disconnect();
+      this.stopEventListener();
+    }
+    status() {
+      return this.transport.getStatus();
+    }
+    getDiagnostics() {
+      return this.transport.getDiagnostics();
+    }
+    async handlePairingUrl(url) {
+      const parsed = PairingHelper.parseUrl(url);
+      if (!parsed) {
+        console.warn("[CapDebug Remote] Invalid pairing URL:", url);
+        return false;
+      }
+      try {
+        await this.connect({
+          sessionId: parsed.sessionId,
+          secret: parsed.secret,
+          signalingUrl: parsed.signalingUrl,
+          isHost: false
+        });
+        return true;
+      } catch (err) {
+        console.error("[CapDebug Remote] Failed to connect via pairing URL:", err);
+        return false;
+      }
+    }
+    startEventListener() {
+      if (this.isListening || typeof window === "undefined") return;
+      this.eventListener = (event) => {
+        const customEvent = event;
+        if (customEvent.detail) {
+          this.transport.send(customEvent.detail);
+        }
+      };
+      window.addEventListener("capdebug", this.eventListener);
+      this.isListening = true;
+    }
+    stopEventListener() {
+      if (!this.isListening || typeof window === "undefined") return;
+      if (this.eventListener) {
+        window.removeEventListener("capdebug", this.eventListener);
+        this.eventListener = null;
+      }
+      this.isListening = false;
+    }
+    setupControlHandler() {
+      this.transport.onControl(async (cmd) => {
+        switch (cmd.type) {
+          case "pause":
             this.store.pause();
-        }
-        /**
-         * Resumes capturing events.
-         */
-        resume() {
+            break;
+          case "resume":
             this.store.resume();
-        }
-        captureConsole() {
-            this.consoleCollector.start();
-        }
-        releaseConsole() {
-            this.consoleCollector.stop();
-        }
-        captureErrors() {
-            this.errorCollector.start();
-        }
-        releaseErrors() {
-            this.errorCollector.stop();
-        }
-        captureFetch(options) {
-            if (options) {
-                this.networkCollector.setOptions(options);
-            }
-            this.networkCollector.start();
-        }
-        releaseFetch() {
-            this.networkCollector.stop();
-        }
-        observeEvent(eventName) {
-            this.browserEventCollector.observe(eventName);
-        }
-        unobserveEvent(eventName) {
-            this.browserEventCollector.unobserve(eventName);
-        }
-    }
-    const CapDebug = new CapDebugManager();
-
-    function formatBytes(bytes) {
-        if (bytes === 0)
-            return '0 B';
-        const k = 1024;
-        const sizes = ['B', 'KB', 'MB', 'GB'];
-        const i = Math.floor(Math.log(bytes) / Math.log(k));
-        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-    }
-    class CapDebugWeb extends core.WebPlugin {
-        async getDeviceInfo() {
-            const nav = typeof navigator !== 'undefined' ? navigator : {};
-            return {
-                manufacturer: 'Web Browser',
-                model: nav.userAgentData?.brands?.[0]?.brand || nav.appName || 'Browser',
-                device: nav.platform || 'Web',
-                systemVersion: nav.appVersion || 'Unknown',
-                architecture: nav.userAgentData?.architecture || 'Unknown',
-                availableProcessors: nav.hardwareConcurrency || 1,
-                isEmulator: false,
-                platform: 'web',
-            };
-        }
-        async getMemoryInfo() {
-            const perf = typeof window !== 'undefined' ? window.performance : null;
-            const memory = perf && perf.memory ? perf.memory : null;
-            if (memory) {
-                return {
-                    appMemoryUsage: memory.usedJSHeapSize,
-                    appMemoryUsageFormatted: formatBytes(memory.usedJSHeapSize),
-                    totalHeap: memory.totalJSHeapSize,
-                    totalHeapFormatted: formatBytes(memory.totalJSHeapSize),
-                    maxHeap: memory.jsHeapSizeLimit,
-                    maxHeapFormatted: formatBytes(memory.jsHeapSizeLimit),
-                    freeHeap: memory.totalJSHeapSize - memory.usedJSHeapSize,
-                    freeHeapFormatted: formatBytes(memory.totalJSHeapSize - memory.usedJSHeapSize),
-                    lowMemory: false,
-                };
-            }
-            return {
-                appMemoryUsageFormatted: 'N/A (Browser non-Chrome)',
-                lowMemory: false,
-            };
-        }
-        async getWebViewInfo() {
-            const nav = typeof navigator !== 'undefined' ? navigator : {};
-            return {
-                userAgent: nav.userAgent || 'Unknown',
-                version: nav.appVersion || 'Unknown',
-                packageName: typeof window !== 'undefined' ? window.location.hostname : 'localhost',
-                debugEnabled: true,
-            };
-        }
-        async getAppInfo() {
-            return {
-                applicationId: typeof window !== 'undefined' ? window.location.host : 'localhost',
-                version: '1.0.0',
-                versionName: '1.0.0 (Web)',
-                versionCode: 1,
-                buildType: typeof process !== 'undefined' && process.env?.NODE_ENV ? process.env.NODE_ENV : 'development',
-            };
-        }
-        async getNetworkInfo() {
-            const nav = typeof navigator !== 'undefined' ? navigator : {};
-            const conn = nav.connection || nav.mozConnection || nav.webkitConnection;
-            return {
-                connected: nav.onLine ?? true,
-                connectionType: conn ? conn.effectiveType || conn.type || 'unknown' : (nav.onLine ? 'online' : 'offline'),
-                metered: conn ? conn.saveData ?? false : false,
-            };
-        }
+            break;
+          case "clear":
+            this.store.clear();
+            break;
+          case "snapshot.request":
+            try {
+              const [device, memory, webView, app, network] = await Promise.allSettled([
+                CapDebugNative.getDeviceInfo(),
+                CapDebugNative.getMemoryInfo(),
+                CapDebugNative.getWebViewInfo(),
+                CapDebugNative.getAppInfo(),
+                CapDebugNative.getNetworkInfo()
+              ]);
+              const snapshot = {
+                device: device.status === "fulfilled" ? device.value : null,
+                memory: memory.status === "fulfilled" ? memory.value : null,
+                webView: webView.status === "fulfilled" ? webView.value : null,
+                app: app.status === "fulfilled" ? app.value : null,
+                network: network.status === "fulfilled" ? network.value : null
+              };
+              this.transport.send({
+                id: "diag_" + Date.now(),
+                timestamp: Date.now(),
+                source: "native",
+                type: "device.snapshot",
+                level: "info",
+                message: "Live native diagnostics snapshot",
+                data: snapshot
+              });
+            } catch (err) {
+              console.error("[CapDebug Remote] Failed snapshot:", err);
+            }
+            break;
+          case "disconnect":
+            this.disconnect();
+            break;
+        }
+      });
+    }
+  }
+
+  class DeepLinkHandler {
+    static parse(url) {
+      return PairingHelper.parseUrl(url);
+    }
+  }
+
+  class CapDebugManager {
+    store;
+    viewerElement = null;
+    isMounted = false;
+    remoteManager;
+    customEventCollector;
+    consoleCollector;
+    errorCollector;
+    networkCollector;
+    browserEventCollector;
+    bridgeCollector;
+    constructor() {
+      this.store = new CapDebugStore();
+      this.remoteManager = new RemoteManager(this.store);
+      this.customEventCollector = new CustomEventCollector(this.store);
+      this.consoleCollector = new ConsoleCollector();
+      this.errorCollector = new ErrorCollector();
+      this.networkCollector = new NetworkCollector();
+      this.browserEventCollector = new BrowserEventCollector();
+      this.bridgeCollector = new BridgeCollector();
+    }
+    get remote() {
+      return this.remoteManager;
+    }
+    async handlePairingUrl(url) {
+      return this.remoteManager.handlePairingUrl(url);
+    }
+    get native() {
+      return CapDebugNative;
+    }
+    get currentStore() {
+      return this.store;
+    }
+    /**
+     * Mounts the CapDebug UI into the DOM and activates collectors.
+     */
+    mount(options = {}) {
+      if (typeof window === "undefined" || typeof document === "undefined") {
+        return;
+      }
+      if (this.isMounted) {
+        this.unmount();
+      }
+      if (options.maxEvents) {
+        this.store.setMaxEvents(options.maxEvents);
+      }
+      if (options.customMaskKeys) {
+        this.store.setCustomMaskKeys(options.customMaskKeys);
+      }
+      this.customEventCollector.start();
+      if (options.console !== false) {
+        this.consoleCollector.start();
+      }
+      if (options.errors !== false) {
+        this.errorCollector.start();
+      }
+      if (options.network) {
+        const netOpts = typeof options.network === "object" ? options.network : {};
+        this.networkCollector.setOptions(netOpts);
+        this.networkCollector.start();
+      }
+      if (options.bridge) {
+        this.bridgeCollector.start();
+      }
+      this.browserEventCollector.start();
+      registerCustomElement();
+      this.viewerElement = document.createElement(CapDebugViewerElement.TAG);
+      this.viewerElement.init(this.store, options);
+      document.body.appendChild(this.viewerElement);
+      this.isMounted = true;
+    }
+    /**
+     * Unmounts CapDebug UI and stops all collectors.
+     */
+    unmount() {
+      if (!this.isMounted) return;
+      if (this.viewerElement && this.viewerElement.parentNode) {
+        this.viewerElement.parentNode.removeChild(this.viewerElement);
+        this.viewerElement = null;
+      }
+      this.customEventCollector.stop();
+      this.consoleCollector.stop();
+      this.errorCollector.stop();
+      this.networkCollector.stop();
+      this.browserEventCollector.stop();
+      this.bridgeCollector.stop();
+      this.isMounted = false;
     }
+    /**
+     * Opens the debug viewer drawer.
+     */
+    show() {
+      if (this.viewerElement) {
+        this.viewerElement.show();
+      }
+    }
+    /**
+     * Closes the debug viewer drawer.
+     */
+    hide() {
+      if (this.viewerElement) {
+        this.viewerElement.hide();
+      }
+    }
+    /**
+     * Toggles the debug viewer drawer open/closed.
+     */
+    toggle() {
+      if (this.viewerElement) {
+        return this.viewerElement.toggle();
+      }
+      return false;
+    }
+    /**
+     * Dispatches a debug event through the CustomEvent bus.
+     */
+    emit(event) {
+      if (typeof window === "undefined") return;
+      window.dispatchEvent(
+        new CustomEvent("capdebug", {
+          detail: {
+            id: event.id,
+            timestamp: event.timestamp || Date.now(),
+            source: event.source || "web",
+            type: event.type,
+            level: event.level || "info",
+            message: event.message,
+            data: event.data,
+            duration: event.duration,
+            platform: event.platform
+          }
+        })
+      );
+    }
+    /**
+     * Clears all recorded events from the store.
+     */
+    clear() {
+      this.store.clear();
+    }
+    /**
+     * Pauses capturing new events.
+     */
+    pause() {
+      this.store.pause();
+    }
+    /**
+     * Resumes capturing events.
+     */
+    resume() {
+      this.store.resume();
+    }
+    captureConsole() {
+      this.consoleCollector.start();
+    }
+    releaseConsole() {
+      this.consoleCollector.stop();
+    }
+    captureErrors() {
+      this.errorCollector.start();
+    }
+    releaseErrors() {
+      this.errorCollector.stop();
+    }
+    captureFetch(options) {
+      if (options) {
+        this.networkCollector.setOptions(options);
+      }
+      this.networkCollector.start();
+    }
+    releaseFetch() {
+      this.networkCollector.stop();
+    }
+    observeEvent(eventName) {
+      this.browserEventCollector.observe(eventName);
+    }
+    unobserveEvent(eventName) {
+      this.browserEventCollector.unobserve(eventName);
+    }
+  }
+  const CapDebug = new CapDebugManager();
+
+  function formatBytes(bytes) {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+  }
+  class CapDebugWeb extends core.WebPlugin {
+    async getDeviceInfo() {
+      const nav = typeof navigator !== "undefined" ? navigator : {};
+      return {
+        manufacturer: "Web Browser",
+        model: nav.userAgentData?.brands?.[0]?.brand || nav.appName || "Browser",
+        device: nav.platform || "Web",
+        systemVersion: nav.appVersion || "Unknown",
+        architecture: nav.userAgentData?.architecture || "Unknown",
+        availableProcessors: nav.hardwareConcurrency || 1,
+        isEmulator: false,
+        platform: "web"
+      };
+    }
+    async getMemoryInfo() {
+      const perf = typeof window !== "undefined" ? window.performance : null;
+      const memory = perf && perf.memory ? perf.memory : null;
+      if (memory) {
+        return {
+          appMemoryUsage: memory.usedJSHeapSize,
+          appMemoryUsageFormatted: formatBytes(memory.usedJSHeapSize),
+          totalHeap: memory.totalJSHeapSize,
+          totalHeapFormatted: formatBytes(memory.totalJSHeapSize),
+          maxHeap: memory.jsHeapSizeLimit,
+          maxHeapFormatted: formatBytes(memory.jsHeapSizeLimit),
+          freeHeap: memory.totalJSHeapSize - memory.usedJSHeapSize,
+          freeHeapFormatted: formatBytes(memory.totalJSHeapSize - memory.usedJSHeapSize),
+          lowMemory: false
+        };
+      }
+      return {
+        appMemoryUsageFormatted: "N/A (Browser non-Chrome)",
+        lowMemory: false
+      };
+    }
+    async getWebViewInfo() {
+      const nav = typeof navigator !== "undefined" ? navigator : {};
+      return {
+        userAgent: nav.userAgent || "Unknown",
+        version: nav.appVersion || "Unknown",
+        packageName: typeof window !== "undefined" ? window.location.hostname : "localhost",
+        debugEnabled: true
+      };
+    }
+    async getAppInfo() {
+      return {
+        applicationId: typeof window !== "undefined" ? window.location.host : "localhost",
+        version: "1.0.0",
+        versionName: "1.0.0 (Web)",
+        versionCode: 1,
+        buildType: typeof process !== "undefined" && process.env?.NODE_ENV ? process.env.NODE_ENV : "development"
+      };
+    }
+    async getNetworkInfo() {
+      const nav = typeof navigator !== "undefined" ? navigator : {};
+      const conn = nav.connection || nav.mozConnection || nav.webkitConnection;
+      return {
+        connected: nav.onLine ?? true,
+        connectionType: conn ? conn.effectiveType || conn.type || "unknown" : nav.onLine ? "online" : "offline",
+        metered: conn ? conn.saveData ?? false : false
+      };
+    }
+  }
 
-    var web = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        CapDebugWeb: CapDebugWeb
-    });
-
-    exports.BridgeCollector = BridgeCollector;
-    exports.BrowserEventCollector = BrowserEventCollector;
-    exports.CapDebug = CapDebug;
-    exports.CapDebugManager = CapDebugManager;
-    exports.CapDebugNative = CapDebugNative;
-    exports.CapDebugStore = CapDebugStore;
-    exports.CapDebugViewerElement = CapDebugViewerElement;
-    exports.ConsoleCollector = ConsoleCollector;
-    exports.CustomEventCollector = CustomEventCollector;
-    exports.DataSanitizer = DataSanitizer;
-    exports.ErrorCollector = ErrorCollector;
-    exports.JsonViewer = JsonViewer;
-    exports.NetworkCollector = NetworkCollector;
-    exports.default = CapDebug;
-    exports.defaultSanitizer = defaultSanitizer;
-    exports.registerCustomElement = registerCustomElement;
-    exports.sanitize = sanitize;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-    return exports;
+  var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CapDebugWeb: CapDebugWeb
+  });
+
+  exports.BridgeCollector = BridgeCollector;
+  exports.BrowserEventCollector = BrowserEventCollector;
+  exports.CapDebug = CapDebug;
+  exports.CapDebugManager = CapDebugManager;
+  exports.CapDebugNative = CapDebugNative;
+  exports.CapDebugStore = CapDebugStore;
+  exports.CapDebugViewerElement = CapDebugViewerElement;
+  exports.ConsoleCollector = ConsoleCollector;
+  exports.CustomEventCollector = CustomEventCollector;
+  exports.DataSanitizer = DataSanitizer;
+  exports.DeepLinkHandler = DeepLinkHandler;
+  exports.ErrorCollector = ErrorCollector;
+  exports.HttpSseSignalingClient = HttpSseSignalingClient;
+  exports.JsonViewer = JsonViewer;
+  exports.NetworkCollector = NetworkCollector;
+  exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
+  exports.PairingHelper = PairingHelper;
+  exports.RemoteEventBuffer = RemoteEventBuffer;
+  exports.RemoteManager = RemoteManager;
+  exports.RemoteProtocol = RemoteProtocol;
+  exports.WebRTCTransport = WebRTCTransport;
+  exports.default = CapDebug;
+  exports.defaultSanitizer = defaultSanitizer;
+  exports.registerCustomElement = registerCustomElement;
+  exports.sanitize = sanitize;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+  return exports;
 
 })({}, capacitorExports);
 //# sourceMappingURL=plugin.js.map