@mcp-fe/event-tracker 0.1.2 → 0.1.4

package/index.js

@@ -1,774 +1,76 @@
-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";
-  // Backend websocket URL to pass into the worker(s)
-  backendWsUrl = "ws://localhost:3001";
-  serviceWorkerRegistration = null;
-  sharedWorker = null;
-  sharedWorkerPort = null;
-  workerType = null;
-  pendingAuthToken = null;
-  // connection status subscribers
-  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 t = e;
-    if (t && typeof t.scope == "string")
-      r = e, i.log("[WorkerClient] Using explicit ServiceWorker registration");
-    else if (e) {
-      const o = e;
-      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", i.info(
-            "[WorkerClient] Using ServiceWorker (explicit registration)"
-          );
-          try {
-            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()) {
-          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 Promise.resolve(!1);
-    try {
-      this.sharedWorker = new SharedWorker(this.sharedWorkerUrl, {
-        type: "module"
-      }), this.sharedWorkerPort = this.sharedWorker.port, this.sharedWorkerPort.start(), await new Promise((r, t) => {
-        let o = !1;
-        const n = setTimeout(() => {
-          if (!o) {
-            const h = this.sharedWorkerPort;
-            h && (h.onmessage = null), t(new Error("SharedWorker initialization timeout"));
-          }
-        }, 2e3), c = this.sharedWorkerPort;
-        if (!c)
-          return clearTimeout(n), t(new Error("SharedWorker port not available"));
-        c.onmessage = (h) => {
-          try {
-            const d = h.data;
-            d && d.type === "CONNECTION_STATUS" && (clearTimeout(n), o = !0, this.workerType = "shared", c.onmessage = null, r(!0));
-          } catch {
-          }
-        };
-      });
-      const e = this.sharedWorkerPort;
-      if (e) {
-        try {
-          const r = {
-            type: "INIT",
-            backendUrl: this.backendWsUrl
-          };
-          this.pendingAuthToken && (r.token = this.pendingAuthToken), e.postMessage(r), this.pendingAuthToken = null;
-        } catch (r) {
-          i.warn(
-            "[WorkerClient] Failed to send INIT to SharedWorker port:",
-            r
-          );
-        }
-        e.onmessage = (r) => {
-          try {
-            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 i.info("[WorkerClient] Using SharedWorker"), !0;
-    } catch (e) {
-      return i.warn(
-        "[WorkerClient] SharedWorker not available, falling back to ServiceWorker:",
-        e
-      ), !1;
-    }
-  }
-  async initServiceWorkerFallback() {
-    if ("serviceWorker" in navigator)
-      try {
-        const e = await navigator.serviceWorker.getRegistration();
-        if (e) {
-          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", "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
-          };
-          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 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, 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(), 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 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 && (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 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(a), i.error(
-              "[WorkerClient] ServiceWorker active instance not available"
-            ), c(
-              new Error("Service worker active instance not available")
-            );
-          i.log("[WorkerClient] Posting message to ServiceWorker:", {
-            type: e,
-            requestId: d
-          }), l.postMessage({ type: e, ...r || {} }, [h.port2]);
-        } catch (l) {
-          clearTimeout(a), i.error(
-            "[WorkerClient] Failed to post message to ServiceWorker:",
-            l
-          ), c(l instanceof Error ? l : new Error(String(l)));
-        }
-      });
-    }
-    throw new Error("No worker registered");
-  }
-  // Fire-and-forget postMessage (no response expected)
-  async post(e, r) {
-    if (this.workerType === "shared" && this.sharedWorkerPort) {
-      try {
-        this.sharedWorkerPort.postMessage({ type: e, ...r || {} });
-      } catch (t) {
-        i.error("[WorkerClient] Failed to post to SharedWorker:", t);
-      }
-      return;
-    }
-    if (this.workerType === "service" && this.serviceWorkerRegistration?.active) {
-      try {
-        this.serviceWorkerRegistration.active.postMessage({
-          type: e,
-          ...r || {}
-        });
-      } catch (t) {
-        i.error(
-          "[WorkerClient] Failed to post to ServiceWorker (active):",
-          t
-        );
-      }
-      return;
-    }
-    if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
-      try {
-        navigator.serviceWorker.controller.postMessage({
-          type: e,
-          ...r || {}
-        });
-      } catch (t) {
-        i.error(
-          "[WorkerClient] Failed to post to ServiceWorker.controller:",
-          t
-        );
-      }
-      return;
-    }
-    if (e === "SET_AUTH_TOKEN" && r) {
-      const t = r.token;
-      typeof t == "string" && (this.pendingAuthToken = t);
-    }
-  }
-  sendAuthTokenToServiceWorker(e) {
-    if (this.serviceWorkerRegistration?.active)
-      try {
-        this.serviceWorkerRegistration.active.postMessage({
-          type: "SET_AUTH_TOKEN",
-          token: e
-        });
-      } catch (r) {
-        console.error(
-          "[WorkerClient] Failed to send auth token to ServiceWorker:",
-          r
-        );
-      }
-    else if ("serviceWorker" in navigator && navigator.serviceWorker.controller)
-      try {
-        navigator.serviceWorker.controller.postMessage({
-          type: "SET_AUTH_TOKEN",
-          token: e
-        });
-      } catch (r) {
-        console.error(
-          "[WorkerClient] Failed to send auth token to ServiceWorker.controller:",
-          r
-        );
-      }
-    else
-      this.pendingAuthToken = e;
-  }
-  // Subscription API for consumers to listen for connection status updates
-  onConnectionStatus(e) {
-    this.connectionStatusCallbacks.add(e);
-  }
-  offConnectionStatus(e) {
-    this.connectionStatusCallbacks.delete(e);
-  }
-  async getConnectionStatus() {
-    try {
-      const e = await this.request(
-        "GET_CONNECTION_STATUS",
-        void 0,
-        2e3
-      );
-      return e && typeof e == "object" && "connected" in e ? !!e.connected : !!e?.connected;
-    } catch {
-      return !1;
-    }
-  }
-  setAuthToken(e) {
-    if (this.pendingAuthToken = e, this.workerType === "shared" && this.sharedWorkerPort)
-      try {
-        this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: e }), this.pendingAuthToken = null;
-      } catch (r) {
-        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", 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 m(s) {
-  const o = (await S()).transaction([f], "readonly").objectStore(f).index("timestamp");
-  return new Promise((n, c) => {
-    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 k = new C();
-async function R(s) {
-  return k.init(s);
+import { workerClient as a, queryEvents as u } from "@mcp-fe/mcp-worker";
+async function f(t) {
+  return a.init(t);
 }
-async function W(s) {
-  const e = { ...s, timestamp: Date.now() };
-  await k.request("STORE_EVENT", { event: e });
+async function o(t) {
+  const n = { ...t, timestamp: Date.now() };
+  await a.request("STORE_EVENT", { event: n });
 }
-async function E() {
-  const s = await m();
-  return Array.isArray(s) ? s : [];
+async function p() {
+  const t = await u();
+  return Array.isArray(t) ? t : [];
 }
-async function P() {
-  return k.getConnectionStatus();
+async function d() {
+  return a.getConnectionStatus();
 }
-function A(s) {
-  k.setAuthToken(s);
+function y(t) {
+  a.setAuthToken(t);
 }
-function I(s) {
-  k.onConnectionStatus(s);
+function C(t) {
+  a.onConnectionStatus(t);
 }
-function b(s) {
-  k.offConnectionStatus(s);
+function l(t) {
+  a.offConnectionStatus(t);
 }
-async function U(s, e, r) {
-  return W({ type: "navigation", from: s, to: e, path: r || e });
+async function v(t, n, e) {
+  return o({ type: "navigation", from: t, to: n, path: e || n });
 }
-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({
+async function g(t, n, e) {
+  const c = t.id || void 0, i = t.className || void 0, s = t.textContent?.trim().substring(0, 100) || void 0, r = t.tagName.toLowerCase();
+  return o({
     type: "click",
-    element: c,
-    elementId: t,
-    elementClass: o,
-    elementText: n,
-    path: e || window.location.pathname,
-    metadata: r
+    element: r,
+    elementId: c,
+    elementClass: i,
+    elementText: s,
+    path: n || window.location.pathname,
+    metadata: e
   });
 }
-async function M(s, e, r) {
-  const t = s.id || void 0, o = s.className || void 0, n = s.tagName.toLowerCase();
-  return W({
+async function w(t, n, e) {
+  const c = t.id || void 0, i = t.className || void 0, s = t.tagName.toLowerCase();
+  return o({
     type: "input",
-    element: n,
-    elementId: t,
-    elementClass: o,
-    path: r || window.location.pathname,
+    element: s,
+    elementId: c,
+    elementClass: i,
+    path: e || window.location.pathname,
     metadata: {
-      valueLength: e?.length || 0,
-      value: e
+      valueLength: n?.length || 0,
+      value: n
     }
   });
 }
-async function _(s, e, r) {
-  return W({
+async function h(t, n, e) {
+  return o({
     type: "custom",
-    path: r || window.location.pathname,
+    path: e || window.location.pathname,
     metadata: {
-      eventName: s,
-      ...e
+      eventName: t,
+      ...n
     }
   });
 }
 export {
-  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
+  d as getConnectionStatus,
+  p as getStoredEvents,
+  f as initEventTracker,
+  l as offConnectionStatus,
+  C as onConnectionStatus,
+  y as setAuthToken,
+  g as trackClick,
+  h as trackCustom,
+  o as trackEvent,
+  w as trackInput,
+  v as trackNavigation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-fe/event-tracker",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "Apache-2.0",
   "homepage": "https://mcp-fe.ai",
   "repository": {
@@ -12,8 +12,8 @@
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",
-  "dependencies": {
-    "@mcp-fe/mcp-worker": "0.1.2"
+  "peerDependencies": {
+    "@mcp-fe/mcp-worker": "^0.1.4"
   },
   "publishConfig": {
     "access": "public"