plugeen 0.0.6 → 0.0.8

package/dist/index.cjs

@@ -1,655 +1,656 @@
-"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);
-
-// src/lib/helpers/brand.ts
-var APP_NAME = "Plugeen";
-var APP_PREFIX = APP_NAME.toLowerCase().slice(0, 2);
+'use strict';
 
-// 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;
+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 {
+    return `anon_${generateUUID()}`;
+  }
 }
-
-// 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 {
+  }
 }
-
-// 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 {
+    return `sess_${generateUUID()}`;
   }
 }
 
-// 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.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var HttpClient = class {
+  constructor(apiUrl, apiKey, maxRetries = 3) {
+    this.apiUrl = apiUrl;
+    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) => {
-  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 })
-  };
-};
-
-// 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()
-      });
-    };
-    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;
+  headers(method = "POST") {
+    const h = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "x-identity-id": getOrCreateIdentityId(),
+      "x-session-id": getOrCreateSessionId()
     };
-    window.addEventListener("popstate", () => changePage());
-    changePage();
-  };
-  return init();
-}
-
-// 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/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);
-}
-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
-  });
-  const mounted = (0, import_hooks.useRef)(true);
-  async function fetchData(initial = false) {
+    if (method !== "GET") h["Content-Type"] = "application/json";
+    return h;
+  }
+  async post(path, body, attempt = 0) {
+    const url = `${this.apiUrl}${path}`;
     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
+      const res = await fetch(url, {
+        method: "POST",
+        headers: this.headers("POST"),
+        body: JSON.stringify(body),
+        keepalive: true,
+        credentials: "omit"
       });
+      if (res.status === 401) return null;
+      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.post(path, body, attempt + 1);
+      }
+      if (res.status >= 200 && res.status < 300) {
+        try {
+          const json = await res.json();
+          return json?.data ?? null;
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    } 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.post(path, body, attempt + 1);
+      }
+      return null;
     }
   }
-  (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
+  async get(path, attempt = 0) {
+    const url = `${this.apiUrl}${path}`;
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        headers: this.headers("GET"),
+        credentials: "omit"
       });
-      if (isStale) {
-        fetchData(false);
+      if (res.status === 401 || res.status === 404) return null;
+      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.get(path, attempt + 1);
       }
-    } else {
-      fetchData(true);
-    }
-    return () => {
-      mounted.current = false;
-    };
-  }, [key]);
-  (0, import_hooks.useEffect)(() => {
-    let interval;
-    if (revalidateTime > 0) {
-      interval = setInterval(() => {
-        fetchData(false);
-      }, revalidateTime);
+      if (res.status >= 200 && res.status < 300) {
+        try {
+          const json = await res.json();
+          return json?.data ?? null;
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    } 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;
     }
-    return () => {
-      clearInterval(interval);
-    };
-  }, [revalidateTime]);
-  return {
-    ...state,
-    refetch: () => fetchData(false)
-  };
-}
-
-// 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;
   }
-  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);
+  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.apiUrl}${path}`, blob);
+    } catch {
+      return false;
     }
-    (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();
-      }
+  }
+  send(path, body, useBeacon = false) {
+    if (useBeacon) {
+      const sent = this.beacon(path, body);
+      if (sent) return;
     }
-  };
-}
+    void this.post(path, body);
+  }
+};
 
-// 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 })
-          }
-        )
-      ]
-    }
+// src/helpers/environment.ts
+function isLocalhost() {
+  if (typeof window === "undefined") return false;
+  const { hostname } = window.location;
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "0.0.0.0" || hostname.endsWith(".local");
+}
+function isOptedOut() {
+  try {
+    return localStorage.getItem("plugeen_opt_out") === "true";
+  } catch {
+    return false;
+  }
+}
+function detectBot() {
+  if (typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent || "";
+  return Boolean(
+    navigator.webdriver || /HeadlessChrome/i.test(ua) || /PhantomJS/i.test(ua) || typeof window !== "undefined" && window._phantom
   );
 }
-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
-  });
-  return render();
+
+// src/helpers/should-skip.ts
+function matchesSkipPattern(patterns) {
+  if (patterns.length === 0 || typeof window === "undefined") return false;
+  const path = window.location.pathname;
+  for (const pattern of patterns) {
+    if (pattern === path) return true;
+    const star = pattern.indexOf("*");
+    if (star !== -1 && path.startsWith(pattern.slice(0, star))) return true;
+  }
+  return false;
+}
+function shouldSkip(options) {
+  if (options.disabled) return true;
+  if (isOptedOut()) return true;
+  if (detectBot()) return true;
+  if (!options.debug && isLocalhost()) return true;
+  if (matchesSkipPattern(options.skipPatterns)) return true;
+  if (options.samplingRate < 1 && Math.random() > options.samplingRate)
+    return true;
+  return false;
 }
 
-// src/lib/plugins/events/index.ts
-function initEvents(api) {
+// src/modules/events.ts
+function createEventsModule(http, options) {
   return {
-    create: (eventName, data) => api.post("/events", {
-      name: eventName,
-      data
-    })
+    create: async (name, data = {}) => {
+      if (shouldSkip(options)) return null;
+      return http.post("/api/events", { name, data, source: "api" });
+    }
   };
 }
 
-// src/lib/plugins/experiments/index.ts
-function initExperiments(api) {
+// src/modules/experiments.ts
+function createExperimentsModule(http, options) {
   return {
-    get: (experimentId) => api.get(`/plugins/experiments/${experimentId}`)
+    get: (id) => {
+      if (shouldSkip(options)) return Promise.resolve(null);
+      return http.get(
+        `/api/v1/experiments/${encodeURIComponent(id)}`
+      );
+    }
   };
 }
 
-// src/lib/plugins/feature-flags/index.ts
-function initFeatureFlags(api) {
+// src/modules/feature-flags.ts
+function createFeatureFlagsModule(http, options) {
   return {
-    get: async (flagKey) => {
-      return api.get(
-        `/plugins/feature-flags/${flagKey}`
+    get: (key) => {
+      if (shouldSkip(options)) return Promise.resolve(null);
+      return http.get(
+        `/api/v1/feature-flags/${encodeURIComponent(key)}`
       );
     }
   };
 }
 
-// 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;
-  }
+// src/modules/identities.ts
+function createIdentitiesModule(http, options) {
   return {
-    // get,
-    set
+    set: async (distinctId, data = {}) => {
+      if (shouldSkip(options)) return null;
+      const result = await http.post("/api/identities", {
+        id: distinctId,
+        ...data
+      });
+      setIdentityId(distinctId);
+      return result;
+    }
   };
 }
 
-// src/lib/plugins/log-tracing/index.ts
-function initLogTracing(api) {
+// src/modules/logs.ts
+function createLogsModule(http, options) {
   return {
-    send: (data) => api.post("/plugins/logs", data)
+    send: (payload) => {
+      if (shouldSkip(options)) return Promise.resolve(null);
+      return http.post("/api/v1/logs", payload);
+    }
   };
 }
 
-// src/lib/plugins/surveys/index.ts
-function initSurveys(api) {
+// src/modules/surveys.ts
+function createSurveysModule(http, options) {
   return {
-    submit: (data) => api.post("/plugins/surveys", data)
+    submit: (payload) => {
+      if (shouldSkip(options)) return Promise.resolve(null);
+      return http.post("/api/v1/surveys", payload);
+    }
   };
 }
 
-// src/lib/plugins/index.ts
-var reset = `
-*, *::before, *::after { box-sizing: border-box; margin: 0; }
-body { line-height: 1.5; -webkit-font-smoothing: antialiased; }
-img, picture, video, canvas, svg { display: block; max-width: 100%; }
-input, button, textarea, select { font: inherit; }
-p, h1, h2, h3, h4, h5, h6 { overflow-wrap: break-word; }
-#root { isolation: isolate; }
-`;
-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/analytics.ts
+function initAnalyticsPlugin(plugeen, http) {
+  if (typeof window === "undefined") return;
+  let pageStartTime = Date.now();
+  let maxScrollDepth = 0;
+  let interactionCount = 0;
+  let pageCount = 0;
+  let currentUrl = window.location.href;
+  const updateScrollDepth = () => {
+    const scrollY = window.scrollY;
+    const { scrollHeight, clientHeight } = document.documentElement;
+    const available = scrollHeight - clientHeight;
+    if (available <= 0) return;
+    const depth = Math.min(100, Math.round(scrollY / available * 100));
+    if (depth > maxScrollDepth) maxScrollDepth = depth;
   };
-};
-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);
+  window.addEventListener("scroll", updateScrollDepth, { passive: true });
+  const countInteraction = () => {
+    interactionCount++;
+  };
+  for (const evt of ["mousedown", "keydown", "touchstart"]) {
+    window.addEventListener(evt, countInteraction, { passive: true });
+  }
+  const trackPageView = () => {
+    pageCount++;
+    const body = {
+      event: "page_view",
+      url: window.location.href,
+      title: document.title,
+      sessionId: getOrCreateSessionId(),
+      referrer: document.referrer || void 0,
+      screenWidth: window.innerWidth,
+      screenHeight: window.innerHeight
+    };
+    void http.post("/api/v1/analytics", body);
+  };
+  const buildPageExitData = () => ({
+    url: currentUrl,
+    time_on_page: Math.round((Date.now() - pageStartTime) / 1e3),
+    scroll_depth: maxScrollDepth,
+    interaction_count: interactionCount,
+    page_count: pageCount
+  });
+  const trackPageExit = (useBeacon = false) => {
+    const data = buildPageExitData();
+    if (useBeacon) {
+      http.send(
+        "/api/events",
+        { name: "page_exit", data, source: "api" },
+        true
+      );
+    } else {
+      void plugeen.events.create("page_exit", data);
+    }
+  };
+  const onRouteChange = () => {
+    if (window.location.href === currentUrl) return;
+    trackPageExit();
+    maxScrollDepth = 0;
+    interactionCount = 0;
+    pageStartTime = Date.now();
+    currentUrl = window.location.href;
+    trackPageView();
+  };
+  const patchHistoryMethod = (method) => {
+    const original = history[method].bind(history);
+    history[method] = (...args) => {
+      original(...args);
+      onRouteChange();
+    };
+  };
+  patchHistoryMethod("pushState");
+  patchHistoryMethod("replaceState");
+  window.addEventListener("popstate", onRouteChange);
+  window.addEventListener("beforeunload", () => {
+    trackPageExit(true);
+  });
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "hidden") {
+      trackPageExit(true);
+    }
+  });
+  trackPageView();
+}
+
+// src/plugins/errors.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(plugeen) {
+  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 plugeen.events.create("error", {
+      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 plugeen.events.create("error", {
+        message,
+        stack,
+        error_type: "UnhandledRejection"
+      });
+    }
+  );
+}
+
+// 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 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])
+        });
+      }
     }
-    if (options.plugins.includes("analytics")) {
-      initAnalytics(api);
+  });
+}
+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])
+      });
+    }
+  });
+  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])
+      });
+    }
+    po.disconnect();
+  };
+  for (const evt of ["keydown", "click", "visibilitychange"]) {
+    addEventListener(evt, finalize, { capture: true, once: true });
+  }
+}
+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])
+        });
+      }
+    }
+  });
+}
+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])
+  });
+}
+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 }
+  );
+}
+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) });
     }
-    return {};
+  };
+  if (document.readyState === "complete") {
+    requestAnimationFrame(tick);
+  } else {
+    window.addEventListener("load", () => requestAnimationFrame(tick), {
+      once: true
+    });
   }
-  return null;
+}
+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/index.ts
-var defaultOptions = {
-  baseUrl: "https://plugeen.app/api",
-  accentColor: "#4f46e5",
-  foregroundColor: "#fff",
-  plugins: []
-};
-var baseInstance = null;
-var clientInstance = null;
+// src/plugins/web-vitals/index.ts
+function initWebVitalsPlugin(plugeen) {
+  initWebVitals((metric) => {
+    void plugeen.events.create("web_vital", {
+      name: metric.name,
+      value: metric.value,
+      ...metric.rating !== void 0 ? { rating: metric.rating } : {}
+    });
+  });
+}
+
+// src/plugins/index.ts
+function initPlugins(plugeen, http, plugins) {
+  for (const plugin of plugins) {
+    if (plugin === "analytics") initAnalyticsPlugin(plugeen, http);
+    else if (plugin === "web-vitals") initWebVitalsPlugin(plugeen);
+    else if (plugin === "errors") initErrorsPlugin(plugeen);
+  }
+}
+
+// src/index.ts
 function createPlugeen(apiKey, options) {
-  const _options = {
-    baseUrl: options?.baseUrl || defaultOptions.baseUrl,
-    accentColor: options?.accentColor || defaultOptions.accentColor,
-    foregroundColor: options?.foregroundColor || defaultOptions.foregroundColor,
-    plugins: options?.plugins || []
-  };
-  if (!apiKey) {
-    console.warn("[Plugeen] Missing data-api-key attribute.");
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new TypeError("[plugeen] apiKey is required");
   }
-  if (!baseInstance) {
-    baseInstance = initBaseSdk(apiKey, _options);
+  if (!options?.apiUrl || typeof options.apiUrl !== "string") {
+    throw new TypeError("[plugeen] apiUrl is required");
   }
-  if (!clientInstance) {
-    clientInstance = initClientSdk(apiKey, _options);
+  const resolved = {
+    apiUrl: options.apiUrl,
+    debug: options.debug ?? false,
+    disabled: options.disabled ?? false,
+    samplingRate: options.samplingRate ?? 1,
+    plugins: options.plugins ?? [],
+    skipPatterns: options.skipPatterns ?? []
+  };
+  const http = new HttpClient(resolved.apiUrl, apiKey);
+  const events = createEventsModule(http, resolved);
+  const identities = createIdentitiesModule(http, resolved);
+  const featureFlags = createFeatureFlagsModule(http, resolved);
+  const logs = createLogsModule(http, resolved);
+  const surveys = createSurveysModule(http, resolved);
+  const experiments = createExperimentsModule(http, resolved);
+  const plugeen = {
+    track: (event, properties) => {
+      void events.create(event, properties ?? {});
+    },
+    events,
+    identities,
+    featureFlags,
+    logs,
+    surveys,
+    experiments
+  };
+  if (resolved.plugins.length > 0) {
+    initPlugins(plugeen, http, resolved.plugins);
   }
-  return baseInstance;
+  return plugeen;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createPlugeen
-});
+
+exports.createPlugeen = createPlugeen;