@mcp-fe/event-tracker 0.0.16 → 0.1.0

package/LICENSE

@@ -188,7 +188,7 @@
       same page as the copyright notice for easier identification within
       third-party archives.
 
-   Copyright 2026 [name of copyright owner]
+   Copyright 2026 Michal Kopecky
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2026 MCP-FE Contributors
+ * Copyright 2026 Michal Kopecky
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/index.js

@@ -1,4 +1,21 @@
-class g {
+const T = typeof process < "u" && process.env?.NODE_ENV === "production", p = typeof process < "u" && process.env?.MCP_DEBUG, v = p === "true" || !T && p !== "false", i = {
+  log: (...s) => {
+    v && console.log(...s);
+  },
+  debug: (...s) => {
+    v && console.debug(...s);
+  },
+  info: (...s) => {
+    console.info(...s);
+  },
+  error: (...s) => {
+    console.error(...s);
+  },
+  warn: (...s) => {
+    v && console.warn(...s);
+  }
+};
+class C {
   // Configurable worker script URLs (defaults kept for backward compatibility)
   sharedWorkerUrl = "/mcp-shared-worker.js";
   serviceWorkerUrl = "/mcp-service-worker.js";
@@ -13,59 +30,127 @@ class g {
   connectionStatusCallbacks = /* @__PURE__ */ new Set();
   // Mutex/promise to prevent concurrent init runs
   initPromise = null;
+  // Initialization state
+  isInitialized = !1;
+  initResolvers = [];
+  // Queue for operations that need to wait for initialization
+  pendingRegistrations = [];
+  // Map to store tool handlers in main thread
+  toolHandlers = /* @__PURE__ */ new Map();
+  // Tool registry for tracking registrations and reference counting
+  toolRegistry = /* @__PURE__ */ new Map();
+  // Subscribers for tool changes (for React hooks reactivity)
+  toolChangeListeners = /* @__PURE__ */ new Map();
   // Initialize and choose worker implementation (prefer SharedWorker)
   // Accept either a ServiceWorkerRegistration OR WorkerInitOptions to configure URLs
   async init(e) {
+    i.log("[WorkerClient] init() called", {
+      hasOptions: !!e,
+      currentWorkerType: this.workerType,
+      initInProgress: !!this.initPromise,
+      timestamp: Date.now()
+    });
     let r;
-    const i = e;
-    if (i && typeof i.scope == "string")
-      r = e;
+    const t = e;
+    if (t && typeof t.scope == "string")
+      r = e, i.log("[WorkerClient] Using explicit ServiceWorker registration");
     else if (e) {
       const o = e;
-      o.sharedWorkerUrl && (this.sharedWorkerUrl = o.sharedWorkerUrl), o.serviceWorkerUrl && (this.serviceWorkerUrl = o.serviceWorkerUrl), o.backendWsUrl && (this.backendWsUrl = o.backendWsUrl);
+      i.log("[WorkerClient] Using WorkerClientInitOptions:", o), o.sharedWorkerUrl && (this.sharedWorkerUrl = o.sharedWorkerUrl), o.serviceWorkerUrl && (this.serviceWorkerUrl = o.serviceWorkerUrl), o.backendWsUrl && (this.backendWsUrl = o.backendWsUrl);
     }
     return this.initPromise ? this.initPromise.then(async () => {
       r && this.workerType !== "service" && await this.init(r);
     }) : (this.initPromise = (async () => {
       try {
         if (r) {
-          this.serviceWorkerRegistration = r, this.workerType = "service", console.log(
+          this.serviceWorkerRegistration = r, this.workerType = "service", i.info(
             "[WorkerClient] Using ServiceWorker (explicit registration)"
           );
           try {
-            const n = { type: "INIT", backendUrl: this.backendWsUrl };
+            const n = {
+              type: "INIT",
+              backendUrl: this.backendWsUrl
+            };
             this.pendingAuthToken && (n.token = this.pendingAuthToken), this.serviceWorkerRegistration.active ? this.serviceWorkerRegistration.active.postMessage(n) : "serviceWorker" in navigator && navigator.serviceWorker.controller && navigator.serviceWorker.controller.postMessage(n);
           } catch {
           }
           return;
         }
-        if (await this.initSharedWorker()) return;
-        await this.initServiceWorkerFallback();
+        if (await this.initSharedWorker()) {
+          this.markAsInitialized();
+          return;
+        }
+        await this.initServiceWorkerFallback(), this.markAsInitialized();
       } finally {
         this.initPromise = null;
       }
     })(), this.initPromise);
   }
+  /**
+   * Mark worker as initialized and process pending registrations
+   * @private
+   */
+  markAsInitialized() {
+    this.isInitialized = !0, i.log(
+      "[WorkerClient] Worker initialized, processing pending operations"
+    ), this.initResolvers.forEach((r) => r()), this.initResolvers = [];
+    const e = [...this.pendingRegistrations];
+    this.pendingRegistrations = [], e.forEach(
+      async ({ name: r, description: t, inputSchema: o, handler: n, resolve: c, reject: h }) => {
+        try {
+          await this.registerToolInternal(
+            r,
+            t,
+            o,
+            n
+          ), c();
+        } catch (d) {
+          h(d instanceof Error ? d : new Error(String(d)));
+        }
+      }
+    );
+  }
+  /**
+   * Wait for worker initialization
+   * @returns Promise that resolves when worker is initialized
+   */
+  async waitForInit() {
+    if (this.isInitialized)
+      return Promise.resolve();
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    return new Promise((e) => {
+      this.initResolvers.push(e);
+    });
+  }
+  /**
+   * Check if worker is initialized
+   */
+  get initialized() {
+    return this.isInitialized;
+  }
   async initSharedWorker() {
     if (typeof SharedWorker > "u")
-      return !1;
+      return Promise.resolve(!1);
     try {
       this.sharedWorker = new SharedWorker(this.sharedWorkerUrl, {
         type: "module"
-      }), this.sharedWorkerPort = this.sharedWorker.port, this.sharedWorkerPort.start(), await new Promise((r, i) => {
+      }), this.sharedWorkerPort = this.sharedWorker.port, this.sharedWorkerPort.start(), await new Promise((r, t) => {
         let o = !1;
         const n = setTimeout(() => {
           if (!o) {
-            const a = this.sharedWorkerPort;
-            a && (a.onmessage = null), i(new Error("SharedWorker initialization timeout"));
+            const h = this.sharedWorkerPort;
+            h && (h.onmessage = null), t(new Error("SharedWorker initialization timeout"));
           }
         }, 2e3), c = this.sharedWorkerPort;
         if (!c)
-          return clearTimeout(n), i(new Error("SharedWorker port not available"));
-        c.onmessage = (a) => {
+          return clearTimeout(n), t(new Error("SharedWorker port not available"));
+        c.onmessage = (h) => {
           try {
-            const s = a.data;
-            s && s.type === "CONNECTION_STATUS" && (clearTimeout(n), o = !0, this.workerType = "shared", c.onmessage = null, r());
+            const d = h.data;
+            d && d.type === "CONNECTION_STATUS" && (clearTimeout(n), o = !0, this.workerType = "shared", c.onmessage = null, r(!0));
           } catch {
           }
         };
@@ -73,30 +158,43 @@ class g {
       const e = this.sharedWorkerPort;
       if (e) {
         try {
-          const r = { type: "INIT", backendUrl: this.backendWsUrl };
+          const r = {
+            type: "INIT",
+            backendUrl: this.backendWsUrl
+          };
           this.pendingAuthToken && (r.token = this.pendingAuthToken), e.postMessage(r), this.pendingAuthToken = null;
         } catch (r) {
-          console.warn("[WorkerClient] Failed to send INIT to SharedWorker port:", r);
+          i.warn(
+            "[WorkerClient] Failed to send INIT to SharedWorker port:",
+            r
+          );
         }
         e.onmessage = (r) => {
           try {
-            const i = r.data;
-            if (i && i.type === "CONNECTION_STATUS") {
-              const o = !!i.connected;
+            const t = r.data;
+            if (t && t.type === "CONNECTION_STATUS") {
+              const o = !!t.connected;
               this.connectionStatusCallbacks.forEach((n) => {
                 try {
                   n(o);
                 } catch {
                 }
               });
-            }
+            } else t && t.type === "CALL_TOOL" && this.handleToolCall(t.toolName, t.args, t.callId).catch(
+              (o) => {
+                i.error(
+                  "[WorkerClient] Failed to handle tool call:",
+                  o
+                );
+              }
+            );
           } catch {
           }
         };
       }
-      return console.log("[WorkerClient] Using SharedWorker"), !0;
+      return i.info("[WorkerClient] Using SharedWorker"), !0;
     } catch (e) {
-      return console.warn(
+      return i.warn(
         "[WorkerClient] SharedWorker not available, falling back to ServiceWorker:",
         e
       ), !1;
@@ -107,68 +205,144 @@ class g {
       try {
         const e = await navigator.serviceWorker.getRegistration();
         if (e) {
-          this.serviceWorkerRegistration = e, this.workerType = "service", console.log(
+          this.serviceWorkerRegistration = e, this.workerType = "service", i.info(
             "[WorkerClient] Using existing ServiceWorker registration"
           );
           return;
         }
         this.serviceWorkerRegistration = await navigator.serviceWorker.register(
           this.serviceWorkerUrl
-        ), this.workerType = "service", console.log("[WorkerClient] Using MCP ServiceWorker (fallback)");
+        ), this.workerType = "service", "serviceWorker" in navigator && navigator.serviceWorker.addEventListener(
+          "message",
+          (r) => {
+            try {
+              const t = r.data;
+              t && t.type === "CALL_TOOL" && this.handleToolCall(
+                t.toolName,
+                t.args,
+                t.callId
+              ).catch((o) => {
+                i.error(
+                  "[WorkerClient] Failed to handle tool call:",
+                  o
+                );
+              });
+            } catch (t) {
+              i.error(
+                "[WorkerClient] Error processing ServiceWorker message:",
+                t
+              );
+            }
+          }
+        ), i.info("[WorkerClient] Using MCP ServiceWorker (fallback)");
         try {
-          const r = { type: "INIT", backendUrl: this.backendWsUrl };
+          const r = {
+            type: "INIT",
+            backendUrl: this.backendWsUrl
+          };
           this.pendingAuthToken && (r.token = this.pendingAuthToken), this.serviceWorkerRegistration.active ? this.serviceWorkerRegistration.active.postMessage(r) : "serviceWorker" in navigator && navigator.serviceWorker.controller && navigator.serviceWorker.controller.postMessage(r), this.pendingAuthToken = null;
         } catch {
         }
       } catch (e) {
-        throw console.error(
-          "[WorkerClient] Failed to register ServiceWorker:",
-          e
-        ), e;
+        throw i.error("[WorkerClient] Failed to register ServiceWorker:", e), e;
       }
     else
       throw new Error("Neither SharedWorker nor ServiceWorker is supported");
   }
   // Low-level request that expects a reply via MessageChannel
-  async request(e, r, i = 5e3) {
-    if (this.workerType === "shared" && this.sharedWorkerPort)
+  async request(e, r, t = 5e3) {
+    if (i.log("[WorkerClient] Request started:", {
+      type: e,
+      payload: r,
+      timeoutMs: t,
+      workerType: this.workerType,
+      hasSharedWorkerPort: !!this.sharedWorkerPort,
+      hasServiceWorkerReg: !!this.serviceWorkerRegistration
+    }), this.workerType === "shared" && this.sharedWorkerPort)
       return new Promise((o, n) => {
-        const c = new MessageChannel(), a = setTimeout(() => {
-          c.port1.onmessage = null, n(new Error("Request timeout"));
-        }, i);
-        c.port1.onmessage = (s) => {
-          clearTimeout(a), s.data && s.data.success ? o(s.data) : s.data && s.data.success === !1 ? n(new Error(s.data.error || "Worker error")) : o(s.data);
+        const c = new MessageChannel(), h = Math.random().toString(36).substring(7), d = Date.now(), g = setTimeout(() => {
+          const a = Date.now() - d;
+          i.error("[WorkerClient] Request timeout:", {
+            type: e,
+            requestId: h,
+            elapsed: a,
+            timeoutMs: t
+          }), c.port1.onmessage = null, n(new Error("Request timeout"));
+        }, t);
+        c.port1.onmessage = (a) => {
+          try {
+            const l = Date.now() - d;
+            i.log("[WorkerClient] Request response received:", {
+              type: e,
+              requestId: h,
+              elapsed: l,
+              success: a.data?.success
+            }), clearTimeout(g), a.data && a.data.success ? o(a.data) : a.data && a.data.success === !1 ? n(new Error(a.data.error || "Worker error")) : o(a.data);
+          } catch (l) {
+            clearTimeout(g), c.port1.onmessage = null, n(
+              l instanceof Error ? l : new Error(String(l))
+            );
+          }
         };
         try {
-          const s = this.sharedWorkerPort;
-          if (!s)
-            return clearTimeout(a), n(new Error("SharedWorker port not available"));
-          s.postMessage({ type: e, ...r || {} }, [c.port2]);
-        } catch (s) {
-          clearTimeout(a), n(s instanceof Error ? s : new Error(String(s)));
+          const a = this.sharedWorkerPort;
+          if (!a)
+            return clearTimeout(g), i.error("[WorkerClient] SharedWorker port not available"), n(new Error("SharedWorker port not available"));
+          i.log("[WorkerClient] Posting message to SharedWorker:", {
+            type: e,
+            requestId: h
+          }), a.postMessage({ type: e, ...r || {} }, [c.port2]);
+        } catch (a) {
+          clearTimeout(g), i.error("[WorkerClient] Failed to post message:", a), n(a instanceof Error ? a : new Error(String(a)));
         }
       });
     if (this.workerType === "service" && this.serviceWorkerRegistration) {
       const o = this.serviceWorkerRegistration;
       if (!o) throw new Error("Service worker registration missing");
-      if (!o.active && (await navigator.serviceWorker.ready, !o.active))
+      if (!o.active && (i.log("[WorkerClient] ServiceWorker not active, waiting..."), await navigator.serviceWorker.ready, !o.active))
         throw new Error("Service worker not active");
       return new Promise((n, c) => {
-        const a = new MessageChannel(), s = setTimeout(() => {
-          a.port1.onmessage = null, c(new Error("Request timeout"));
-        }, i);
-        a.port1.onmessage = (l) => {
-          clearTimeout(s), l.data && l.data.success ? n(l.data) : l.data && l.data.success === !1 ? c(new Error(l.data.error || "Worker error")) : n(l.data);
+        const h = new MessageChannel(), d = Math.random().toString(36).substring(7), g = Date.now(), a = setTimeout(() => {
+          const l = Date.now() - g;
+          i.error("[WorkerClient] ServiceWorker request timeout:", {
+            type: e,
+            requestId: d,
+            elapsed: l,
+            timeoutMs: t
+          }), h.port1.onmessage = null, c(new Error("Request timeout"));
+        }, t);
+        h.port1.onmessage = (l) => {
+          try {
+            const u = Date.now() - g;
+            i.log("[WorkerClient] ServiceWorker response received:", {
+              type: e,
+              requestId: d,
+              elapsed: u,
+              success: l.data?.success
+            }), clearTimeout(a), l.data && l.data.success ? n(l.data) : l.data && l.data.success === !1 ? c(new Error(l.data.error || "Worker error")) : n(l.data);
+          } catch (u) {
+            clearTimeout(a), h.port1.onmessage = null, c(
+              u instanceof Error ? u : new Error(String(u))
+            );
+          }
         };
         try {
           const l = o.active;
           if (!l)
-            return clearTimeout(s), c(
+            return clearTimeout(a), i.error(
+              "[WorkerClient] ServiceWorker active instance not available"
+            ), c(
               new Error("Service worker active instance not available")
             );
-          l.postMessage({ type: e, ...r || {} }, [a.port2]);
+          i.log("[WorkerClient] Posting message to ServiceWorker:", {
+            type: e,
+            requestId: d
+          }), l.postMessage({ type: e, ...r || {} }, [h.port2]);
         } catch (l) {
-          clearTimeout(s), c(l instanceof Error ? l : new Error(String(l)));
+          clearTimeout(a), i.error(
+            "[WorkerClient] Failed to post message to ServiceWorker:",
+            l
+          ), c(l instanceof Error ? l : new Error(String(l)));
         }
       });
     }
@@ -179,8 +353,8 @@ class g {
     if (this.workerType === "shared" && this.sharedWorkerPort) {
       try {
         this.sharedWorkerPort.postMessage({ type: e, ...r || {} });
-      } catch (i) {
-        console.error("[WorkerClient] Failed to post to SharedWorker:", i);
+      } catch (t) {
+        i.error("[WorkerClient] Failed to post to SharedWorker:", t);
       }
       return;
     }
@@ -190,10 +364,10 @@ class g {
           type: e,
           ...r || {}
         });
-      } catch (i) {
-        console.error(
+      } catch (t) {
+        i.error(
           "[WorkerClient] Failed to post to ServiceWorker (active):",
-          i
+          t
         );
       }
       return;
@@ -204,17 +378,17 @@ class g {
           type: e,
           ...r || {}
         });
-      } catch (i) {
-        console.error(
+      } catch (t) {
+        i.error(
           "[WorkerClient] Failed to post to ServiceWorker.controller:",
-          i
+          t
         );
       }
       return;
     }
     if (e === "SET_AUTH_TOKEN" && r) {
-      const i = r.token;
-      typeof i == "string" && (this.pendingAuthToken = i);
+      const t = r.token;
+      typeof t == "string" && (this.pendingAuthToken = t);
     }
   }
   sendAuthTokenToServiceWorker(e) {
@@ -269,82 +443,304 @@ class g {
       try {
         this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: e }), this.pendingAuthToken = null;
       } catch (r) {
-        console.error(
+        i.error(
           "[WorkerClient] Failed to set auth token on SharedWorker:",
           r
         );
       }
     else this.workerType === "service" && (this.sendAuthTokenToServiceWorker(e), this.pendingAuthToken = null);
   }
+  /**
+   * Register a custom MCP tool dynamically
+   *
+   * The handler function runs in the MAIN THREAD (browser context), not in the worker.
+   * This means you have full access to:
+   * - React context, hooks, Redux store
+   * - DOM API, window, localStorage
+   * - All your imports and dependencies
+   * - Closures and external variables
+   *
+   * The worker acts as a proxy - it receives MCP tool calls and forwards them
+   * to your handler via MessageChannel.
+   *
+   * @param name - Tool name
+   * @param description - Tool description
+   * @param inputSchema - JSON Schema for tool inputs
+   * @param handler - Async function that handles the tool execution (runs in main thread)
+   * @returns Promise that resolves when tool is registered
+   *
+   * @example With full access to imports and context:
+   * ```typescript
+   * import { z } from 'zod';
+   * import { useMyStore } from './store';
+   *
+   * const store = useMyStore();
+   *
+   * await client.registerTool(
+   *   'validate_user',
+   *   'Validate user data',
+   *   { type: 'object', properties: { username: { type: 'string' } } },
+   *   async (args: any) => {
+   *     // Full access to everything!
+   *     const schema = z.object({ username: z.string().min(3) });
+   *     const validated = schema.parse(args);
+   *
+   *     // Can access store, context, etc.
+   *     const currentUser = store.getState().user;
+   *
+   *     return {
+   *       content: [{
+   *         type: 'text',
+   *         text: JSON.stringify({ validated, currentUser })
+   *       }]
+   *     };
+   *   }
+   * );
+   * ```
+   */
+  async registerTool(e, r, t, o) {
+    return this.isInitialized ? this.registerToolInternal(e, r, t, o) : (i.log(
+      `[WorkerClient] Queueing tool registration '${e}' (worker not initialized yet)`
+    ), new Promise((n, c) => {
+      this.pendingRegistrations.push({
+        name: e,
+        description: r,
+        inputSchema: t,
+        handler: o,
+        resolve: n,
+        reject: c
+      });
+    }));
+  }
+  /**
+   * Internal method to register tool (assumes worker is initialized)
+   * @private
+   */
+  async registerToolInternal(e, r, t, o) {
+    const n = this.toolRegistry.get(e);
+    if (n) {
+      n.refCount++, i.log(
+        `[WorkerClient] Incremented ref count for '${e}': ${n.refCount}`
+      ), this.toolHandlers.set(e, o), this.notifyToolChange(e);
+      return;
+    }
+    this.toolHandlers.set(e, o), await this.request("REGISTER_TOOL", {
+      name: e,
+      description: r,
+      inputSchema: t,
+      handlerType: "proxy"
+      // Tell worker this is a proxy handler
+    }), this.toolRegistry.set(e, {
+      refCount: 1,
+      description: r,
+      inputSchema: t,
+      isRegistered: !0
+    }), i.log(
+      `[WorkerClient] Registered tool '${e}' with main-thread handler`
+    ), this.notifyToolChange(e);
+  }
+  /**
+   * Unregister a previously registered MCP tool
+   * @param name - Tool name to unregister
+   * @returns Promise that resolves to true if tool was found and removed
+   */
+  async unregisterTool(e) {
+    const r = this.toolRegistry.get(e);
+    if (!r)
+      return i.warn(`[WorkerClient] Cannot unregister '${e}': not found`), !1;
+    if (r.refCount--, i.log(
+      `[WorkerClient] Decremented ref count for '${e}': ${r.refCount}`
+    ), r.refCount <= 0) {
+      this.toolHandlers.delete(e);
+      const t = await this.request(
+        "UNREGISTER_TOOL",
+        { name: e }
+      );
+      return this.toolRegistry.delete(e), i.log(`[WorkerClient] Unregistered tool '${e}'`), this.notifyToolChange(e), t?.success ?? !1;
+    }
+    return this.notifyToolChange(e), !0;
+  }
+  /**
+   * Subscribe to tool changes for a specific tool
+   * Returns unsubscribe function
+   */
+  onToolChange(e, r) {
+    this.toolChangeListeners.has(e) || this.toolChangeListeners.set(e, /* @__PURE__ */ new Set());
+    const t = this.toolChangeListeners.get(e);
+    t.add(r);
+    const o = this.toolRegistry.get(e);
+    return r(o ? {
+      refCount: o.refCount,
+      isRegistered: o.isRegistered
+    } : null), () => {
+      t.delete(r), t.size === 0 && this.toolChangeListeners.delete(e);
+    };
+  }
+  /**
+   * Notify all listeners about tool changes
+   * @private
+   */
+  notifyToolChange(e) {
+    const r = this.toolChangeListeners.get(e);
+    if (!r || r.size === 0) return;
+    const t = this.toolRegistry.get(e), o = t ? {
+      refCount: t.refCount,
+      isRegistered: t.isRegistered
+    } : null;
+    r.forEach((n) => {
+      try {
+        n(o);
+      } catch (c) {
+        i.error("[WorkerClient] Error in tool change listener:", c);
+      }
+    });
+  }
+  /**
+   * Get tool info from registry
+   */
+  getToolInfo(e) {
+    const r = this.toolRegistry.get(e);
+    return r ? {
+      refCount: r.refCount,
+      isRegistered: r.isRegistered
+    } : null;
+  }
+  /**
+   * Get all registered tool names
+   */
+  getRegisteredTools() {
+    return Array.from(this.toolRegistry.keys()).filter(
+      (e) => this.toolRegistry.get(e)?.isRegistered
+    );
+  }
+  /**
+   * Check if a tool is registered
+   */
+  isToolRegistered(e) {
+    return this.toolRegistry.get(e)?.isRegistered ?? !1;
+  }
+  /**
+   * Handle tool call from worker - execute handler in main thread and return result
+   * @private
+   */
+  async handleToolCall(e, r, t) {
+    i.log(`[WorkerClient] Handling tool call: ${e}`, {
+      callId: t,
+      args: r
+    });
+    try {
+      const o = this.toolHandlers.get(e);
+      if (!o)
+        throw new Error(`Tool handler not found: ${e}`);
+      const n = await o(r);
+      this.sendToolCallResult(t, { success: !0, result: n });
+    } catch (o) {
+      i.error(`[WorkerClient] Tool call failed: ${e}`, o), this.sendToolCallResult(t, {
+        success: !1,
+        error: o instanceof Error ? o.message : "Unknown error"
+      });
+    }
+  }
+  /**
+   * Send tool call result back to worker
+   * @private
+   */
+  sendToolCallResult(e, r) {
+    const t = {
+      type: "TOOL_CALL_RESULT",
+      callId: e,
+      success: r.success,
+      result: r.result,
+      error: r.error
+    };
+    if (this.workerType === "shared" && this.sharedWorkerPort)
+      try {
+        this.sharedWorkerPort.postMessage(t);
+      } catch (o) {
+        i.error(
+          "[WorkerClient] Failed to send result to SharedWorker:",
+          o
+        );
+      }
+    else if (this.workerType === "service" && this.serviceWorkerRegistration?.active)
+      try {
+        this.serviceWorkerRegistration.active.postMessage(t);
+      } catch (o) {
+        i.error(
+          "[WorkerClient] Failed to send result to ServiceWorker:",
+          o
+        );
+      }
+  }
 }
-const W = "user-activity-db", v = 1, k = "user-events";
-async function p() {
-  return new Promise((t, e) => {
-    const r = indexedDB.open(W, v);
-    r.onerror = () => e(r.error), r.onsuccess = () => t(r.result), r.onupgradeneeded = (i) => {
-      const o = i.target.result;
-      if (!o.objectStoreNames.contains(k)) {
-        const n = o.createObjectStore(k, { keyPath: "id" });
+const w = "user-activity-db", y = 1, f = "user-events";
+async function S() {
+  return new Promise((s, e) => {
+    const r = indexedDB.open(w, y);
+    r.onerror = () => e(r.error), r.onsuccess = () => s(r.result), r.onupgradeneeded = (t) => {
+      const o = t.target.result;
+      if (!o.objectStoreNames.contains(f)) {
+        const n = o.createObjectStore(f, { keyPath: "id" });
         n.createIndex("timestamp", "timestamp", { unique: !1 }), n.createIndex("type", "type", { unique: !1 }), n.createIndex("path", "path", { unique: !1 });
       }
     };
   });
 }
-async function f(t) {
-  const o = (await p()).transaction([k], "readonly").objectStore(k).index("timestamp");
+async function m(s) {
+  const o = (await S()).transaction([f], "readonly").objectStore(f).index("timestamp");
   return new Promise((n, c) => {
-    const a = o.getAll();
-    a.onsuccess = () => {
-      let s = a.result;
-      s.sort((l, d) => d.timestamp - l.timestamp), n(s);
-    }, a.onerror = () => c(a.error);
+    const h = o.getAll();
+    h.onsuccess = () => {
+      let d = h.result;
+      d.sort((g, a) => a.timestamp - g.timestamp), n(d);
+    }, h.onerror = () => c(h.error);
   });
 }
-const h = new g();
-async function T(t) {
-  return h.init(t);
+const k = new C();
+async function R(s) {
+  return k.init(s);
 }
-async function u(t) {
-  const e = { ...t, timestamp: Date.now() };
-  await h.request("STORE_EVENT", { event: e });
+async function W(s) {
+  const e = { ...s, timestamp: Date.now() };
+  await k.request("STORE_EVENT", { event: e });
 }
-async function m() {
-  const t = await f();
-  return Array.isArray(t) ? t : [];
+async function E() {
+  const s = await m();
+  return Array.isArray(s) ? s : [];
 }
-async function w() {
-  return h.getConnectionStatus();
+async function P() {
+  return k.getConnectionStatus();
 }
-function y(t) {
-  h.setAuthToken(t);
+function A(s) {
+  k.setAuthToken(s);
 }
-function S(t) {
-  h.onConnectionStatus(t);
+function I(s) {
+  k.onConnectionStatus(s);
 }
-function C(t) {
-  h.offConnectionStatus(t);
+function b(s) {
+  k.offConnectionStatus(s);
 }
-async function E(t, e, r) {
-  return u({ type: "navigation", from: t, to: e, path: r || e });
+async function U(s, e, r) {
+  return W({ type: "navigation", from: s, to: e, path: r || e });
 }
-async function b(t, e, r) {
-  const i = t.id || void 0, o = t.className || void 0, n = t.textContent?.trim().substring(0, 100) || void 0, c = t.tagName.toLowerCase();
-  return u({
+async function N(s, e, r) {
+  const t = s.id || void 0, o = s.className || void 0, n = s.textContent?.trim().substring(0, 100) || void 0, c = s.tagName.toLowerCase();
+  return W({
     type: "click",
     element: c,
-    elementId: i,
+    elementId: t,
     elementClass: o,
     elementText: n,
     path: e || window.location.pathname,
     metadata: r
   });
 }
-async function A(t, e, r) {
-  const i = t.id || void 0, o = t.className || void 0, n = t.tagName.toLowerCase();
-  return u({
+async function M(s, e, r) {
+  const t = s.id || void 0, o = s.className || void 0, n = s.tagName.toLowerCase();
+  return W({
     type: "input",
     element: n,
-    elementId: i,
+    elementId: t,
     elementClass: o,
     path: r || window.location.pathname,
     metadata: {
@@ -353,26 +749,26 @@ async function A(t, e, r) {
     }
   });
 }
-async function N(t, e, r) {
-  return u({
+async function _(s, e, r) {
+  return W({
     type: "custom",
     path: r || window.location.pathname,
     metadata: {
-      eventName: t,
+      eventName: s,
       ...e
     }
   });
 }
 export {
-  w as getConnectionStatus,
-  m as getStoredEvents,
-  T as initEventTracker,
-  C as offConnectionStatus,
-  S as onConnectionStatus,
-  y as setAuthToken,
-  b as trackClick,
-  N as trackCustom,
-  u as trackEvent,
-  A as trackInput,
-  E as trackNavigation
+  P as getConnectionStatus,
+  E as getStoredEvents,
+  R as initEventTracker,
+  b as offConnectionStatus,
+  I as onConnectionStatus,
+  A as setAuthToken,
+  N as trackClick,
+  _ as trackCustom,
+  W as trackEvent,
+  M as trackInput,
+  U as trackNavigation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-fe/event-tracker",
-  "version": "0.0.16",
+  "version": "0.1.0",
   "license": "Apache-2.0",
   "homepage": "https://mcp-fe.ai",
   "repository": {
@@ -13,7 +13,7 @@
   "main": "./index.js",
   "types": "./index.d.ts",
   "dependencies": {
-    "@mcp-fe/mcp-worker": "0.0.16"
+    "@mcp-fe/mcp-worker": "0.1.0"
   },
   "publishConfig": {
     "access": "public"