plugeen 0.0.7 → 0.0.9

package/dist/index.cjs

@@ -1,651 +1,528 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  createPlugeen: () => createPlugeen
-});
-module.exports = __toCommonJS(src_exports);
+'use strict';
 
-// src/lib/helpers/brand.ts
-var APP_NAME = "Plugeen";
-var APP_PREFIX = APP_NAME.toLowerCase().slice(0, 2);
-
-// src/lib/helpers/storage.ts
-function withPrefix(key) {
-  return `${APP_PREFIX}_${key}`;
-}
-function ensureServerStore() {
-  if (!globalThis.Plugeen) {
-    globalThis.Plugeen = {};
+// src/helpers/uuid.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
   }
-  return globalThis.Plugeen;
-}
-function serverStorage() {
-  const set = (key, value) => {
-    ensureServerStore()[key] = value;
-    return value;
-  };
-  const get = (key) => ensureServerStore()[key];
-  return {
-    get,
-    set
-  };
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.floor(Math.random() * 16);
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
 }
-function clientStorage() {
-  const set = (key, value) => {
-    localStorage.setItem(
-      withPrefix(key),
-      typeof value === "string" ? value : JSON.stringify(value)
-    );
-    return value;
-  };
-  const get = (key) => {
-    try {
-      const raw = localStorage.getItem(withPrefix(key));
-      if (!raw) throw new Error("No data found");
-      if (typeof raw === "string") return raw;
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
+
+// src/storage.ts
+var IDENTITY_KEY = "plugeen_anon_id";
+var SESSION_KEY = "plugeen_session_id";
+var SESSION_TS_KEY = "plugeen_session_ts";
+var SESSION_TTL = 18e5;
+var memStore = {};
+function getOrCreateIdentityId() {
+  try {
+    let id = localStorage.getItem(IDENTITY_KEY);
+    if (!id) {
+      id = `anon_${generateUUID()}`;
+      localStorage.setItem(IDENTITY_KEY, id);
     }
-  };
-  return {
-    get,
-    set
-  };
-}
-function getStorage() {
-  if (typeof window === "undefined") return serverStorage();
-  return clientStorage();
+    return id;
+  } catch {
+    if (!memStore[IDENTITY_KEY]) {
+      memStore[IDENTITY_KEY] = `anon_${generateUUID()}`;
+    }
+    return memStore[IDENTITY_KEY];
+  }
 }
-
-// src/lib/helpers/identity.ts
-function getOrCreateIdentity() {
-  const storage = getStorage();
-  const identity = storage.get("identity");
-  if (identity) return identity;
-  const newId = crypto.randomUUID();
-  storage.set("identity", newId);
-  return newId;
+function setIdentityId(id) {
+  try {
+    localStorage.setItem(IDENTITY_KEY, id);
+  } catch {
+    memStore[IDENTITY_KEY] = id;
+  }
 }
-
-// src/lib/helpers/session.ts
-var SESSION_KEY = "pl_session";
 function getOrCreateSessionId() {
   try {
-    if (typeof window === "undefined") return "";
     const existing = sessionStorage.getItem(SESSION_KEY);
-    if (existing) return existing;
-    throw new Error("No session ID");
-  } catch {
-    const id = crypto.randomUUID();
+    const ts = sessionStorage.getItem(SESSION_TS_KEY);
+    if (existing && ts && Date.now() - parseInt(ts, 10) < SESSION_TTL) {
+      sessionStorage.setItem(SESSION_TS_KEY, String(Date.now()));
+      return existing;
+    }
+    sessionStorage.removeItem(SESSION_KEY);
+    sessionStorage.removeItem(SESSION_TS_KEY);
+    const id = `sess_${generateUUID()}`;
     sessionStorage.setItem(SESSION_KEY, id);
+    sessionStorage.setItem(SESSION_TS_KEY, String(Date.now()));
+    return id;
+  } catch {
+    const existing = memStore[SESSION_KEY];
+    const ts = memStore[SESSION_TS_KEY];
+    if (existing && ts && Date.now() - parseInt(ts, 10) < SESSION_TTL) {
+      memStore[SESSION_TS_KEY] = String(Date.now());
+      return existing;
+    }
+    const id = `sess_${generateUUID()}`;
+    memStore[SESSION_KEY] = id;
+    memStore[SESSION_TS_KEY] = String(Date.now());
     return id;
   }
 }
 
-// src/lib/helpers/api/index.ts
-function getHeaders(apiKey, method) {
-  const headers = new Headers();
-  const identity = getStorage().get("identity");
-  headers.append("x-identity-id", identity || getOrCreateIdentity());
-  headers.set("Authorization", `Bearer ${apiKey}`);
-  headers.set("x-session-id", getOrCreateSessionId());
-  if (method === "POST" || method === "PUT") {
-    headers.set("Content-Type", "application/json");
+// src/helpers/http-client/index.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var HttpClient = class {
+  constructor(baseUrl, apiKey, maxRetries = 3) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.maxRetries = maxRetries;
   }
-  return headers;
-}
-async function fetcher(params) {
-  return fetch(`${params.options.baseUrl}${params.url}`, {
-    method: params.method,
-    body: params.body ? JSON.stringify({ ...params.body, source: "api" }) : void 0,
-    headers: getHeaders(params.apiKey, params.method)
-  }).then((response) => response.json()).then((response) => response.data);
-}
-var createApi = (apiKey, options) => {
+  headers(method) {
+    const h = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "x-identity-id": getOrCreateIdentityId(),
+      "x-session-id": getOrCreateSessionId()
+    };
+    if (method !== "GET") h["Content-Type"] = "application/json";
+    return h;
+  }
+  async request(path, { attempt = 0, method, body }) {
+    const url = `${this.baseUrl}${path}`;
+    try {
+      const res = await fetch(url, {
+        method,
+        headers: this.headers(method),
+        credentials: "omit",
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (res.status === 401 || res.status === 404) return [null, res.status];
+      if ((res.status >= 500 || res.status === 429) && attempt < this.maxRetries) {
+        const jitter = 0.85 + Math.random() * 0.3;
+        await delay(500 * 2 ** attempt * jitter);
+        return this.request(path, {
+          body,
+          attempt: attempt + 1,
+          method
+        });
+      }
+      if (res.status >= 200 && res.status < 300) {
+        try {
+          const json = await res.json();
+          return [json.data, null];
+        } catch {
+          return [null, "Failed to parse json"];
+        }
+      }
+      return [null, "Error"];
+    } catch (err) {
+      if (err instanceof TypeError && attempt < this.maxRetries) {
+        const jitter = 0.85 + Math.random() * 0.3;
+        await delay(500 * 2 ** attempt * jitter);
+        return this.get(path, attempt + 1);
+      }
+      return [null, err];
+    }
+  }
+  async post(path, body, attempt = 0) {
+    return this.request(path, {
+      attempt,
+      body,
+      method: "POST"
+    });
+  }
+  async get(path, attempt = 0) {
+    return this.request(path, {
+      attempt,
+      method: "GET"
+    });
+  }
+  beacon(path, body) {
+    if (typeof navigator === "undefined" || !navigator.sendBeacon) return false;
+    try {
+      const blob = new Blob([JSON.stringify(body)], {
+        type: "application/json"
+      });
+      return navigator.sendBeacon(`${this.baseUrl}${path}`, blob);
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/plugins/events/index.ts
+function createEventsModule(http) {
   return {
-    post: (url, body) => fetcher({ url, method: "POST", body, options, apiKey }),
-    put: (url, body) => fetcher({ url, method: "PUT", body, options, apiKey }),
-    get: (url) => fetcher({ url, method: "GET", options, apiKey })
+    create: async (name, data = {}) => {
+      return http.post("/events", { name, data, source: "api" });
+    }
   };
-};
+}
 
-// src/lib/plugins/analytics/index.ts
-function initAnalytics(api) {
-  const init = () => {
-    const changePage = () => {
-      api.post("/plugins/analytics", {
-        event: "page_view",
-        url: location.href,
-        title: document.title,
-        referrer: document.referrer ?? "",
-        screenWidth: window.screen.width,
-        screenHeight: window.screen.height,
-        sessionId: getOrCreateSessionId()
+// src/plugins/identities/index.ts
+function createIdentitiesModule(http) {
+  return {
+    create: async (distinctId, data = {}) => {
+      const result = await http.post("/identities", {
+        id: distinctId,
+        ...data
       });
+      setIdentityId(distinctId);
+      return result;
+    }
+  };
+}
+
+// src/plugins/analytics/index.ts
+function initAnalyticsPlugin(http) {
+  if (typeof window === "undefined") return;
+  let pageStartTime = Date.now();
+  let pageCount = 0;
+  let currentUrl = window.location.href;
+  const trackPageView = () => {
+    pageCount++;
+    void http.post("/v1/analytics", {
+      event: "page_view",
+      url: window.location.href,
+      title: document.title,
+      sessionId: getOrCreateSessionId(),
+      referrer: document.referrer || void 0,
+      screenWidth: window.innerWidth,
+      screenHeight: window.innerHeight
+    });
+  };
+  const trackPageExit = (useBeacon = false) => {
+    const data = {
+      event: "page_exit",
+      url: window.location.href,
+      title: document.title,
+      sessionId: getOrCreateSessionId(),
+      referrer: document.referrer || void 0,
+      screenWidth: window.innerWidth,
+      screenHeight: window.innerHeight,
+      metadata: {
+        timeOnPage: Math.round((Date.now() - pageStartTime) / 1e3),
+        pageCount
+      }
     };
-    const pushState = history.pushState;
-    history.pushState = function(...args) {
-      pushState.apply(this, args);
-      changePage();
-    };
-    const replaceState = history.replaceState;
-    history.replaceState = function(...args) {
-      replaceState.apply(this, args);
-      changePage;
+    if (useBeacon) {
+      http.beacon("/v1/analytics", data);
+    } else {
+      void http.post("/v1/analytics", data);
+    }
+  };
+  const onRouteChange = () => {
+    if (window.location.href === currentUrl) return;
+    trackPageExit();
+    pageStartTime = Date.now();
+    currentUrl = window.location.href;
+    trackPageView();
+  };
+  const patchHistoryMethod = (method) => {
+    const original = history[method].bind(history);
+    history[method] = (...args) => {
+      original(...args);
+      onRouteChange();
     };
-    window.addEventListener("popstate", () => changePage());
-    changePage();
   };
-  return init();
+  patchHistoryMethod("pushState");
+  patchHistoryMethod("replaceState");
+  window.addEventListener("popstate", onRouteChange);
+  window.addEventListener("beforeunload", () => trackPageExit(true));
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "hidden") {
+      trackPageExit(true);
+    }
+  });
+  trackPageView();
 }
 
-// src/lib/plugins/chat/index.tsx
-var import_signals2 = require("@preact/signals");
-var import_lucide_preact = require("lucide-preact");
-
-// src/store/theme.ts
-var import_signals = require("@preact/signals");
-var theme = (0, import_signals.signal)({
-  accentColor: "",
-  foregroundColor: ""
-});
-
-// src/components/button.tsx
-var import_jsx_runtime = require("preact/jsx-runtime");
-function Button({ children, disabled, fullWidth }) {
-  const deactivated = disabled;
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    "button",
-    {
-      type: "submit",
-      disabled: deactivated,
-      style: {
-        background: theme.value.accentColor,
-        color: theme.value.foregroundColor,
-        width: fullWidth ? "100%" : "max-content",
-        border: "none",
-        borderRadius: "8px",
-        padding: "8px 0",
-        fontWeight: "600",
-        fontSize: "13px",
-        opacity: deactivated ? 0.5 : 1,
-        cursor: deactivated ? "not allowed" : "pointer",
-        transition: "all 0.4s ease"
-      },
-      children
+// src/plugins/logs/index.ts
+var EXTENSION_PREFIXES = [
+  "chrome-extension://",
+  "moz-extension://",
+  "safari-extension://",
+  "edge-extension://"
+];
+function isExtensionSource(str) {
+  if (!str) return false;
+  const lower = str.toLowerCase();
+  return EXTENSION_PREFIXES.some((prefix) => lower.includes(prefix));
+}
+function initErrorsPlugin(http) {
+  if (typeof window === "undefined") return;
+  window.addEventListener("error", (event) => {
+    if (isExtensionSource(event.filename) || isExtensionSource(event.error?.stack))
+      return;
+    if (event.error === null && event.message === "Script error.") return;
+    void http.post("/v1/logs", {
+      message: event.message || "Unknown Error",
+      filename: event.filename,
+      lineno: event.lineno,
+      colno: event.colno,
+      stack: event.error?.stack,
+      error_type: event.error?.name || "Error"
+    });
+  });
+  window.addEventListener(
+    "unhandledrejection",
+    (event) => {
+      const { reason } = event;
+      if (isExtensionSource(reason?.stack))
+        return;
+      let message = "Unknown Error";
+      let stack;
+      if (reason instanceof Error) {
+        message = reason.message;
+        stack = reason.stack;
+      } else if (typeof reason === "string") {
+        message = reason;
+      } else if (reason !== null && typeof reason === "object" && "message" in reason) {
+        message = String(reason.message);
+      }
+      void http.post("/v1/logs", {
+        message,
+        stack,
+        error_type: "UnhandledRejection"
+      });
     }
   );
 }
 
-// src/hooks/use-query.ts
-var import_hooks = require("preact/hooks");
-var cache = /* @__PURE__ */ new Map();
-function serializeKey(key) {
-  return typeof key === "string" ? key : JSON.stringify(key);
+// src/plugins/web-vitals/helpers.ts
+function getRating(value, thresholds) {
+  if (value > thresholds[1]) return "poor";
+  if (value > thresholds[0]) return "needs-improvement";
+  return "good";
+}
+function getActivationStart() {
+  const nav = performance.getEntriesByType(
+    "navigation"
+  )[0];
+  return nav?.activationStart ?? 0;
+}
+function getNavEntry() {
+  const entry = performance.getEntriesByType("navigation")[0];
+  if (entry && entry.responseStart > 0 && entry.responseStart < performance.now())
+    return entry;
+}
+function observe(type, cb, opts) {
+  try {
+    if (!PerformanceObserver.supportedEntryTypes.includes(type)) return;
+    const po = new PerformanceObserver((list) => {
+      Promise.resolve().then(() => cb(list.getEntries()));
+    });
+    po.observe({
+      type,
+      buffered: true,
+      ...opts ?? {}
+    });
+    return po;
+  } catch {
+    return void 0;
+  }
 }
-function useQuery({
-  queryKey,
-  queryFn,
-  revalidateTime = 0
-}) {
-  const key = serializeKey(queryKey);
-  const [state, setState] = (0, import_hooks.useState)({
-    data: void 0,
-    error: void 0,
-    isLoading: true,
-    isFetching: false
+function observeFCP(cb) {
+  const reported = /* @__PURE__ */ new Set();
+  observe("paint", (entries) => {
+    for (const entry of entries) {
+      if (entry.name === "first-contentful-paint" && !reported.has("FCP")) {
+        reported.add("FCP");
+        const value = Math.max(entry.startTime - getActivationStart(), 0);
+        cb({
+          name: "FCP",
+          value: Math.round(value),
+          rating: getRating(value, [1800, 3e3])
+        });
+      }
+    }
   });
-  const mounted = (0, import_hooks.useRef)(true);
-  async function fetchData(initial = false) {
-    try {
-      setState((prev) => ({
-        ...prev,
-        isLoading: initial,
-        isFetching: !initial,
-        error: void 0
-      }));
-      const data = await queryFn();
-      cache.set(key, {
-        data,
-        updatedAt: Date.now()
-      });
-      if (!mounted.current) return;
-      setState({
-        data,
-        error: void 0,
-        isLoading: false,
-        isFetching: false
-      });
-    } catch (error) {
-      if (!mounted.current) return;
-      setState({
-        data: void 0,
-        error,
-        isLoading: false,
-        isFetching: false
+}
+function observeLCP(cb) {
+  let reported = false;
+  const po = observe("largest-contentful-paint", (entries) => {
+    if (reported) return;
+    const last = entries[entries.length - 1];
+    if (last) {
+      const value = Math.max(last.startTime - getActivationStart(), 0);
+      cb({
+        name: "LCP",
+        value: Math.round(value),
+        rating: getRating(value, [2500, 4e3])
       });
     }
-  }
-  (0, import_hooks.useEffect)(() => {
-    mounted.current = true;
-    const cached = cache.get(key);
-    if (cached) {
-      const isStale = Date.now() - cached.updatedAt > revalidateTime;
-      setState({
-        data: cached.data,
-        error: void 0,
-        isLoading: false,
-        isFetching: isStale
+  });
+  if (!po) return;
+  const finalize = () => {
+    if (reported) return;
+    reported = true;
+    const records = po.takeRecords();
+    if (records.length > 0) {
+      const last = records[records.length - 1];
+      const value = Math.max(last.startTime - getActivationStart(), 0);
+      cb({
+        name: "LCP",
+        value: Math.round(value),
+        rating: getRating(value, [2500, 4e3])
       });
-      if (isStale) {
-        fetchData(false);
-      }
-    } else {
-      fetchData(true);
-    }
-    return () => {
-      mounted.current = false;
-    };
-  }, [key]);
-  (0, import_hooks.useEffect)(() => {
-    let interval;
-    if (revalidateTime > 0) {
-      interval = setInterval(() => {
-        fetchData(false);
-      }, revalidateTime);
     }
-    return () => {
-      clearInterval(interval);
-    };
-  }, [revalidateTime]);
-  return {
-    ...state,
-    refetch: () => fetchData(false)
+    po.disconnect();
   };
-}
-
-// src/lib/helpers/ui.ts
-var import_preact = require("preact");
-var noopUnmount = () => {
-};
-function getOrCreateRoot(target, id) {
-  const existing = document.getElementById(id);
-  if (existing instanceof HTMLDivElement) {
-    return existing;
+  for (const evt of ["keydown", "click", "visibilitychange"]) {
+    addEventListener(evt, finalize, { capture: true, once: true });
   }
-  const container = document.createElement("div");
-  container.id = id;
-  target.appendChild(container);
-  return container;
 }
-function renderUI({
-  component: Component,
-  id,
-  options
-}) {
-  if (typeof document === "undefined") {
-    return { render: () => void 0, unmount: noopUnmount };
-  }
-  theme.value = {
-    accentColor: options.accentColor,
-    foregroundColor: options.foregroundColor
-  };
-  const target = document.body;
-  const mount = () => {
-    const container = getOrCreateRoot(document.body, id);
-    if (container.parentElement !== target) {
-      target.appendChild(container);
-    }
-    (0, import_preact.render)(Component, container);
-    return container;
-  };
-  return {
-    render: mount,
-    unmount: () => {
-      const el = document.getElementById(id);
-      if (el) {
-        (0, import_preact.render)(null, el);
-        el.remove();
+function observeCLS(cb) {
+  let sessionValue = 0;
+  let sessionEntries = [];
+  let clsValue = 0;
+  observe("layout-shift", (entries) => {
+    for (const raw of entries) {
+      const entry = raw;
+      if (entry.hadRecentInput) continue;
+      const last = sessionEntries[sessionEntries.length - 1];
+      const first = sessionEntries[0];
+      if (sessionEntries.length > 0 && last && first && entry.startTime - last.startTime < 1e3 && entry.startTime - first.startTime < 5e3) {
+        sessionValue += entry.value;
+        sessionEntries.push(entry);
+      } else {
+        sessionValue = entry.value;
+        sessionEntries = [entry];
+      }
+      if (sessionValue > clsValue) {
+        clsValue = sessionValue;
+        const rounded = Math.round(clsValue * 1e4) / 1e4;
+        cb({
+          name: "CLS",
+          value: rounded,
+          rating: getRating(clsValue, [0.1, 0.25])
+        });
       }
     }
-  };
-}
-
-// src/lib/plugins/chat/index.tsx
-var import_jsx_runtime2 = require("preact/jsx-runtime");
-var pluginName = "chats";
-var text = (0, import_signals2.signal)("");
-var open = (0, import_signals2.signal)(false);
-var submitting = (0, import_signals2.signal)(false);
-function FloatingChat({
-  api,
-  options: { accentColor, foregroundColor },
-  id
-}) {
-  const identity = getStorage().get("identity");
-  const { data, refetch, isLoading, error } = useQuery({
-    queryKey: [id],
-    queryFn: async () => {
-      return await api.get("/plugins/chats");
-    },
-    revalidateTime: 1e4
   });
-  const onSubmit = async () => {
-    submitting.value = true;
-    await api.post("/plugins/chats", {
-      text: text.value
-    });
-    await refetch();
-    text.value = "";
-    submitting.value = false;
-  };
-  if (!data && !error && isLoading) return null;
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
-    "div",
-    {
-      style: {
-        position: "fixed",
-        right: "24px",
-        bottom: "24px",
-        zIndex: "9999",
-        fontFamily: "system-ui, sans-serif"
-      },
-      children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
-          "div",
-          {
-            style: {
-              width: "320px",
-              marginBottom: "12px",
-              borderRadius: "12px",
-              boxShadow: "0 8px 32px rgba(0,0,0,0.18)",
-              background: "#fff",
-              overflow: "hidden",
-              maxHeight: open.value ? "500px" : "0px",
-              opacity: open.value ? 1 : 0,
-              transition: "all 0.4s ease"
-            },
-            children: [
-              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                "div",
-                {
-                  style: {
-                    background: accentColor,
-                    color: "#fff",
-                    padding: "14px 16px",
-                    fontWeight: "600",
-                    fontSize: "14px"
-                  },
-                  children: "Chat with us"
-                }
-              ),
-              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                "div",
-                {
-                  style: {
-                    display: "grid",
-                    height: "200px",
-                    overflowY: "auto",
-                    padding: "16px",
-                    gap: "4px"
-                  },
-                  children: data?.messages.map((m, index) => {
-                    const isMine = identity === m.identity.id;
-                    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
-                      "div",
-                      {
-                        style: {
-                          justifySelf: isMine ? "start" : "end",
-                          width: "max-content"
-                        },
-                        children: [
-                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                            "p",
-                            {
-                              style: {
-                                padding: "2px 8px",
-                                borderRadius: "8px",
-                                width: "max-content",
-                                background: isMine ? "silver" : accentColor,
-                                color: isMine ? "black" : foregroundColor
-                              },
-                              children: m.text
-                            }
-                          ),
-                          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                            "span",
-                            {
-                              style: {
-                                fontSize: "12px",
-                                color: "silver",
-                                textAlign: isMine ? "left" : "right"
-                              },
-                              children: new Date(m.createdAt).toLocaleDateString()
-                            }
-                          )
-                        ]
-                      },
-                      m.text + index.toString()
-                    );
-                  })
-                }
-              ),
-              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
-                "form",
-                {
-                  onSubmit: (e) => {
-                    e.preventDefault();
-                    onSubmit();
-                  },
-                  style: { padding: "12px 16px" },
-                  children: [
-                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                      "textarea",
-                      {
-                        value: text.value,
-                        onInput: (e) => {
-                          text.value = e.target?.value;
-                        },
-                        name: "message",
-                        placeholder: "Send us a message\u2026",
-                        rows: 3,
-                        style: {
-                          width: "100%",
-                          border: "1px solid #e5e7eb",
-                          borderRadius: "8px",
-                          padding: "8px",
-                          fontSize: "13px",
-                          resize: "none",
-                          outline: "none",
-                          boxSizing: "border-box"
-                        }
-                      }
-                    ),
-                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Button, { fullWidth: true, disabled: !text.value, children: submitting.value ? "Sending" : "Send" })
-                  ]
-                }
-              )
-            ]
-          }
-        ),
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-          "button",
-          {
-            type: "button",
-            onClick: () => {
-              open.value = !open.value;
-            },
-            "aria-label": "Open chat",
-            style: {
-              transform: `rotate(${open.value ? 180 : 0}deg)`,
-              transition: "transform 0.4s ease",
-              width: "52px",
-              height: "52px",
-              borderRadius: "50%",
-              background: accentColor,
-              border: "none",
-              cursor: "pointer",
-              display: "flex",
-              alignItems: "center",
-              justifyContent: "center",
-              boxShadow: "0 4px 16px rgba(0,0,0,0.18)",
-              marginLeft: "auto"
-            },
-            children: open.value ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_preact.X, { color: foregroundColor }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_preact.MessageCircle, { color: foregroundColor })
-          }
-        )
-      ]
-    }
-  );
 }
-function initChat(api, options) {
-  const id = crypto.randomUUID();
-  const { render } = renderUI({
-    component: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(FloatingChat, { id, api, options }),
-    id: pluginName,
-    options
+function observeTTFB(cb) {
+  const nav = getNavEntry();
+  if (!nav) return;
+  const value = Math.max(nav.responseStart - getActivationStart(), 0);
+  cb({
+    name: "TTFB",
+    value: Math.round(value),
+    rating: getRating(value, [800, 1800])
   });
-  return render();
-}
-
-// src/lib/plugins/events/index.ts
-function initEvents(api) {
-  return {
-    create: (eventName, data) => api.post("/events", {
-      name: eventName,
-      data
-    })
-  };
 }
-
-// src/lib/plugins/experiments/index.ts
-function initExperiments(api) {
-  return {
-    get: (experimentId) => api.get(`/plugins/experiments/${experimentId}`)
-  };
+function observeINP(cb) {
+  const interactions = /* @__PURE__ */ new Map();
+  let worstDuration = 0;
+  observe(
+    "event",
+    (entries) => {
+      for (const raw of entries) {
+        const entry = raw;
+        if (!entry.interactionId) continue;
+        const existing = interactions.get(entry.interactionId) ?? 0;
+        if (entry.duration > existing) {
+          interactions.set(entry.interactionId, entry.duration);
+          if (entry.duration > worstDuration) {
+            worstDuration = entry.duration;
+            cb({
+              name: "INP",
+              value: Math.round(entry.duration),
+              rating: getRating(entry.duration, [200, 500])
+            });
+          }
+        }
+      }
+    },
+    { durationThreshold: 40 }
+  );
 }
-
-// src/lib/plugins/feature-flags/index.ts
-function initFeatureFlags(api) {
-  return {
-    get: async (flagKey) => {
-      return api.get(
-        `/plugins/feature-flags/${flagKey}`
-      );
+function observeFPS(cb) {
+  if (typeof requestAnimationFrame === "undefined") return;
+  let frames = 0;
+  const duration = 2e3;
+  const start = performance.now();
+  const tick = () => {
+    frames++;
+    if (performance.now() - start < duration) {
+      requestAnimationFrame(tick);
+    } else {
+      cb({ name: "FPS", value: Math.round(frames / duration * 1e3) });
     }
   };
-}
-
-// src/lib/plugins/identities/index.ts
-function initIdentities(api) {
-  const storage = getStorage();
-  async function set(distinctId, data) {
-    const res = await api.post("/identities", { ...data, id: distinctId });
-    storage.set("identity", distinctId);
-    return res;
+  if (document.readyState === "complete") {
+    requestAnimationFrame(tick);
+  } else {
+    window.addEventListener("load", () => requestAnimationFrame(tick), {
+      once: true
+    });
   }
-  return {
-    // get,
-    set
-  };
 }
-
-// src/lib/plugins/log-tracing/index.ts
-function initLogTracing(api) {
-  return {
-    send: (data) => api.post("/plugins/logs", data)
-  };
+function initWebVitals(cb) {
+  if (typeof window === "undefined" || typeof PerformanceObserver === "undefined")
+    return;
+  observeFCP(cb);
+  observeLCP(cb);
+  observeCLS(cb);
+  observeTTFB(cb);
+  observeINP(cb);
+  observeFPS(cb);
 }
 
-// src/lib/plugins/surveys/index.ts
-function initSurveys(api) {
-  return {
-    submit: (data) => api.post("/plugins/surveys", data)
-  };
+// src/plugins/web-vitals/index.ts
+function initWebVitalsPlugin(http) {
+  initWebVitals((metric) => {
+    http.post("/v1/web-vitals", {
+      name: metric.name,
+      value: metric.value,
+      ...metric.rating !== void 0 ? { rating: metric.rating } : {}
+    });
+  });
 }
 
-// src/lib/plugins/index.ts
-var reset = `
-*, *::before, *::after { box-sizing: border-box; margin: 0; }
-body { line-height: 1.5; -webkit-font-smoothing: antialiased; }
-`;
-var initBaseSdk = (apiKey, options) => {
-  const api = createApi(apiKey, options);
-  return {
-    events: initEvents(api),
-    identities: initIdentities(api),
-    featureFlags: initFeatureFlags(api),
-    logs: initLogTracing(api),
-    surveys: initSurveys(api),
-    experiments: initExperiments(api)
+// src/plugins/index.ts
+function initPlugins(http, plugins) {
+  const initializers = {
+    analytics: initAnalyticsPlugin(http),
+    "web-vitals": initWebVitalsPlugin(http),
+    errors: initErrorsPlugin(http)
   };
-};
-function initClientSdk(apiKey, options) {
-  const isBrowser = typeof window !== "undefined";
-  const api = createApi(apiKey, options);
-  if (isBrowser) {
-    const style = document.createElement("style");
-    style.innerHTML = reset;
-    document.head.appendChild(style);
-    if (options.plugins.includes("chats")) {
-      initChat(api, options);
-    }
-    if (options.plugins.includes("analytics")) {
-      initAnalytics(api);
-    }
-    return {};
-  }
-  return null;
+  plugins.map((p) => initializers[p]);
 }
 
-// src/lib/index.ts
-var defaultOptions = {
-  baseUrl: "https://plugeen.app/api",
-  accentColor: "#4f46e5",
-  foregroundColor: "#fff",
+// src/index.ts
+var defaults = {
+  baseUrl: "https://dev.plugeen.app/api",
+  debug: false,
   plugins: []
 };
-var baseInstance = null;
-var clientInstance = null;
 function createPlugeen(apiKey, options) {
-  const _options = {
-    baseUrl: options?.baseUrl || defaultOptions.baseUrl,
-    accentColor: options?.accentColor || defaultOptions.accentColor,
-    foregroundColor: options?.foregroundColor || defaultOptions.foregroundColor,
-    plugins: options?.plugins || []
+  const resolved = {
+    baseUrl: options.baseUrl || defaults.baseUrl,
+    debug: options.debug || defaults.debug,
+    plugins: options.plugins || defaults.plugins
   };
   if (!apiKey) {
-    console.warn("[Plugeen] Missing data-api-key attribute.");
-  }
-  if (!baseInstance) {
-    baseInstance = initBaseSdk(apiKey, _options);
+    throw new TypeError("[plugeen] apiKey is required");
   }
-  if (!clientInstance) {
-    clientInstance = initClientSdk(apiKey, _options);
+  const http = new HttpClient(resolved.baseUrl, apiKey);
+  const events = createEventsModule(http);
+  const identities = createIdentitiesModule(http);
+  const plugeen = {
+    track: (event, properties) => {
+      void events.create(event, properties);
+    },
+    identify: (userId, data) => identities.create(userId, data)
+  };
+  if (resolved.plugins.length > 0) {
+    initPlugins(http, resolved.plugins);
   }
-  return baseInstance;
+  return plugeen;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createPlugeen
-});
+
+exports.createPlugeen = createPlugeen;