@graph8/sdk 0.2.0

package/dist/react.mjs

@@ -0,0 +1,974 @@
+"use client";
+
+// src/react.tsx
+import { createContext, useContext, useEffect } from "react";
+
+// src/core.ts
+import { jitsuAnalytics } from "@jitsu/js";
+
+// src/forms.ts
+var DEFAULT_API = "https://be.graph8.com";
+var createFormsClient = (writeKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API;
+  return {
+    /**
+     * Look up known fields for an email address.
+     *
+     * Use this in progressive forms: after the user enters their email,
+     * check what graph8 already knows and only show missing fields.
+     */
+    async lookup(email) {
+      const resp = await fetch(`${baseUrl}/api/v1/public/enrich/lookup`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Write-Key": writeKey
+        },
+        body: JSON.stringify({ email })
+      });
+      if (!resp.ok) {
+        return { found: false, known_fields: {}, missing_fields: [] };
+      }
+      const data = await resp.json();
+      return data.data || data;
+    }
+  };
+};
+
+// src/utils.ts
+var isServer = typeof window === "undefined";
+
+// src/visitors.ts
+var DEFAULT_API2 = "https://be.graph8.com";
+var createVisitorsClient = (writeKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API2;
+  let intentInterval = null;
+  const headers = () => ({
+    "Content-Type": "application/json",
+    "X-Write-Key": writeKey
+  });
+  return {
+    /** Identify the current visitor's company from their IP address. */
+    async identify() {
+      if (isServer) return { company_name: null, company_domain: null, industry: null, employee_count: null, city: null, country: null, confidence: 0 };
+      const resp = await fetch(`${baseUrl}/api/v1/public/visitors/company`, { headers: headers() });
+      if (!resp.ok) return { company_name: null, company_domain: null, industry: null, employee_count: null, city: null, country: null, confidence: 0 };
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Get engagement score for the current visitor. */
+    async score() {
+      if (isServer) return { engagement: 0, intent: "low", signals: [] };
+      const resp = await fetch(`${baseUrl}/api/v1/public/visitors/score`, { headers: headers() });
+      if (!resp.ok) return { engagement: 0, intent: "low", signals: [] };
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Listen for visitors matching an intent level. Polls every 30 seconds. */
+    onIntent(level, callback) {
+      if (isServer) return () => {
+      };
+      const check = async () => {
+        try {
+          const [company, scoreData] = await Promise.all([
+            this.identify(),
+            this.score()
+          ]);
+          if (scoreData.intent === level || level === "medium" && scoreData.intent === "high") {
+            callback({ ...company, ...scoreData });
+          }
+        } catch {
+        }
+      };
+      check();
+      intentInterval = setInterval(check, 3e4);
+      return () => {
+        if (intentInterval) clearInterval(intentInterval);
+      };
+    }
+  };
+};
+
+// src/copilot.ts
+var DEFAULT_API3 = "https://be.graph8.com";
+var createCopilotClient = (writeKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API3;
+  const listeners = /* @__PURE__ */ new Map();
+  const actions = /* @__PURE__ */ new Map();
+  let widgetEl = null;
+  const emit = (event, data = {}) => {
+    listeners.get(event)?.forEach((cb) => cb(data));
+  };
+  return {
+    /** Open the copilot widget. */
+    open(config) {
+      if (isServer) return;
+      if (widgetEl) widgetEl.remove();
+      const position = config?.position || "bottom-right";
+      const posStyle = position === "bottom-left" ? "left:16px;" : "right:16px;";
+      const iframe = document.createElement("iframe");
+      iframe.src = `${baseUrl}/copilot/embed?write_key=${writeKey}&theme=${config?.theme || "auto"}`;
+      iframe.style.cssText = `position:fixed;bottom:16px;${posStyle}width:400px;height:600px;border:none;border-radius:12px;box-shadow:0 8px 32px rgba(0,0,0,0.15);z-index:99998;`;
+      iframe.id = "g8-copilot-widget";
+      document.body.appendChild(iframe);
+      widgetEl = iframe;
+      emit("open");
+    },
+    /** Send a message to the copilot programmatically. */
+    async ask(message) {
+      const resp = await fetch(`${baseUrl}/api/v1/public/copilot/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Write-Key": writeKey },
+        body: JSON.stringify({ message })
+      });
+      if (!resp.ok) return "Sorry, I could not process that request.";
+      const data = await resp.json();
+      return data.response || data.data?.response || "";
+    },
+    /** Register a custom action the copilot can trigger. */
+    registerAction(name, handler) {
+      actions.set(name, handler);
+    },
+    /** Listen for copilot events. */
+    on(event, callback) {
+      if (!listeners.has(event)) listeners.set(event, []);
+      listeners.get(event).push(callback);
+    },
+    /** Close the copilot widget. */
+    close() {
+      if (widgetEl) {
+        widgetEl.remove();
+        widgetEl = null;
+        emit("close");
+      }
+    }
+  };
+};
+
+// src/chat.ts
+var DEFAULT_API4 = "https://be.graph8.com";
+var createChatClient = (writeKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API4;
+  const listeners = /* @__PURE__ */ new Map();
+  let widgetEl = null;
+  let ws = null;
+  const emit = (event, data = {}) => {
+    listeners.get(event)?.forEach((cb) => cb(data));
+  };
+  return {
+    /** Open the chat widget. */
+    open(config) {
+      if (isServer) return;
+      if (widgetEl) widgetEl.remove();
+      const position = config?.position || "bottom-right";
+      const posStyle = position === "bottom-left" ? "left:16px;" : "right:16px;";
+      const iframe = document.createElement("iframe");
+      iframe.src = `${baseUrl}/webchat/embed?write_key=${writeKey}&theme=${config?.theme || "auto"}`;
+      iframe.style.cssText = `position:fixed;bottom:16px;${posStyle}width:380px;height:560px;border:none;border-radius:12px;box-shadow:0 8px 32px rgba(0,0,0,0.15);z-index:99997;`;
+      iframe.id = "g8-chat-widget";
+      document.body.appendChild(iframe);
+      widgetEl = iframe;
+      emit("open");
+    },
+    /** Send a message. */
+    send(message) {
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: "message", content: message }));
+      }
+    },
+    /** Listen for chat events. */
+    on(event, callback) {
+      if (!listeners.has(event)) listeners.set(event, []);
+      listeners.get(event).push(callback);
+    },
+    /** Configure the chat appearance. */
+    configure(config) {
+      if (widgetEl && widgetEl instanceof HTMLIFrameElement) {
+        widgetEl.contentWindow?.postMessage({ type: "g8_chat_config", config }, "*");
+      }
+    },
+    /** Close the chat widget. */
+    close() {
+      if (ws) {
+        ws.close();
+        ws = null;
+      }
+      if (widgetEl) {
+        widgetEl.remove();
+        widgetEl = null;
+      }
+      emit("close");
+    }
+  };
+};
+
+// src/calendar.ts
+var DEFAULT_API5 = "https://be.graph8.com";
+var createCalendarClient = (apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API5;
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    /** Show a booking modal overlay. */
+    show(config) {
+      if (isServer) return;
+      const url = `${baseUrl}/appointments/${config.username}/${config.eventType}`;
+      const params = new URLSearchParams();
+      if (config.prefill?.name) params.set("name", config.prefill.name);
+      if (config.prefill?.email) params.set("email", config.prefill.email);
+      const iframe = document.createElement("iframe");
+      iframe.src = `${url}?${params.toString()}`;
+      iframe.style.cssText = "position:fixed;top:0;left:0;width:100%;height:100%;border:none;z-index:99999;background:rgba(0,0,0,0.5);";
+      iframe.id = "g8-calendar-modal";
+      document.body.appendChild(iframe);
+      const onKey = (e) => {
+        if (e.key === "Escape") {
+          iframe.remove();
+          document.removeEventListener("keydown", onKey);
+        }
+      };
+      document.addEventListener("keydown", onKey);
+    },
+    /** Embed booking widget inline in a container element. */
+    embed(selector, config) {
+      if (isServer) return;
+      const container = document.querySelector(selector);
+      if (!container) return;
+      const url = `${baseUrl}/appointments/${config.username}/${config.eventType}`;
+      const iframe = document.createElement("iframe");
+      iframe.src = url;
+      iframe.style.cssText = "width:100%;min-height:600px;border:none;border-radius:8px;";
+      container.appendChild(iframe);
+    },
+    /** Get available time slots for an event type. */
+    async slots(username, eventSlug, range) {
+      const params = new URLSearchParams({
+        start_date: range.start,
+        end_date: range.end
+      });
+      const resp = await fetch(`${baseUrl}/appointments/public/slots?username=${username}&event_slug=${eventSlug}&${params.toString()}`);
+      if (!resp.ok) return [];
+      const data = await resp.json();
+      return data.slots || data.data || [];
+    },
+    /** Book a meeting programmatically. */
+    async book(request) {
+      const resp = await fetch(`${baseUrl}/appointments/public/bookings`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request)
+      });
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      const emit = listeners.get("booked");
+      if (emit) emit.forEach((cb) => cb(data));
+      return data;
+    },
+    /** Listen for calendar events. */
+    on(event, callback) {
+      if (!listeners.has(event)) listeners.set(event, []);
+      listeners.get(event).push(callback);
+    }
+  };
+};
+
+// src/enrich.ts
+var DEFAULT_API6 = "https://be.graph8.com";
+var createEnrichClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API6;
+  const headers = () => ({
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`
+  });
+  return {
+    /** Look up a person by email, LinkedIn, or name + company. Costs 1 credit. */
+    async person(params) {
+      const resp = await fetch(`${baseUrl}/api/v1/enrichment/lookup/person`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(params)
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Look up a company by domain or name. Costs 1 credit. */
+    async company(params) {
+      const resp = await fetch(`${baseUrl}/api/v1/enrichment/lookup/company`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(params)
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Verify an email address. Costs 1 credit. */
+    async verifyEmail(email) {
+      const resp = await fetch(`${baseUrl}/api/v1/enrichment/verify-email`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ email })
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Search 300M+ contacts with filters. Credits charged per result. */
+    async search(filters, page = 1, limit = 25) {
+      const resp = await fetch(`${baseUrl}/api/v1/search/contacts`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ filters, page, limit })
+      });
+      const data = await resp.json();
+      return data.data || data;
+    }
+  };
+};
+
+// src/sequences.ts
+var DEFAULT_API7 = "https://be.graph8.com";
+var createSequencesClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API7;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  return {
+    async list(page = 1, limit = 50) {
+      const resp = await fetch(`${baseUrl}/api/v1/sequences?page=${page}&limit=${limit}`, { headers: headers() });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    async add(config) {
+      await fetch(`${baseUrl}/api/v1/sequences/${config.sequenceId}/contacts`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ contact_ids: config.contactIds, list_id: config.listId })
+      });
+    }
+  };
+};
+
+// src/campaigns.ts
+var DEFAULT_API8 = "https://be.graph8.com";
+var createCampaignsClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API8;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  return {
+    async list(page = 1, limit = 50) {
+      const resp = await fetch(`${baseUrl}/api/v1/campaigns?page=${page}&limit=${limit}`, { headers: headers() });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    async get(campaignId) {
+      const resp = await fetch(`${baseUrl}/api/v1/campaigns/${campaignId}`, { headers: headers() });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    async create(config) {
+      const resp = await fetch(`${baseUrl}/api/v1/campaigns`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(config)
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    async launch(campaignId) {
+      await fetch(`${baseUrl}/api/v1/campaigns/${campaignId}/launch`, {
+        method: "POST",
+        headers: headers()
+      });
+    },
+    async stats(campaignId) {
+      const resp = await fetch(`${baseUrl}/api/v1/campaigns/${campaignId}/stats`, { headers: headers() });
+      const data = await resp.json();
+      return data.data || data;
+    }
+  };
+};
+
+// src/integrations.ts
+var DEFAULT_API9 = "https://be.graph8.com";
+var createIntegrationsClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API9;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  return {
+    async list() {
+      const resp = await fetch(`${baseUrl}/api/v1/integrations`, { headers: headers() });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    async connect(provider, config) {
+      await fetch(`${baseUrl}/api/v1/integrations/connect`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ provider, ...config })
+      });
+    },
+    async sync(provider, config) {
+      await fetch(`${baseUrl}/api/v1/integrations/sync`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ provider, ...config })
+      });
+    }
+  };
+};
+
+// src/signals.ts
+var DEFAULT_API10 = "https://be.graph8.com";
+var createSignalsClient = (key, isApiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API10;
+  const headers = () => isApiKey ? { "Content-Type": "application/json", "Authorization": `Bearer ${key}` } : { "Content-Type": "application/json", "X-Write-Key": key };
+  const endpoint = isApiKey ? "/api/v1/signals/company" : "/api/v1/public/signals/company";
+  return {
+    /** Get intent signals for a specific company domain. */
+    async company(domain) {
+      const resp = await fetch(`${baseUrl}${endpoint}?domain=${encodeURIComponent(domain)}`, { headers: headers() });
+      if (!resp.ok) return { domain, score: 0, intent: "low", signals: [], last_seen: null };
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Stream intent signals - calls callback every 30s with latest data. */
+    stream(domains, callback) {
+      const check = async () => {
+        try {
+          const results = await Promise.all(domains.map((d) => this.company(d)));
+          callback(results);
+        } catch {
+        }
+      };
+      check();
+      const interval = setInterval(check, 3e4);
+      return () => clearInterval(interval);
+    }
+  };
+};
+
+// src/analytics.ts
+var DEFAULT_API11 = "https://be.graph8.com";
+var createAnalyticsClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API11;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  return {
+    async overview(config) {
+      const params = new URLSearchParams();
+      if (config?.period) params.set("period", config.period);
+      const resp = await fetch(`${baseUrl}/api/v1/analytics/overview?${params.toString()}`, { headers: headers() });
+      if (!resp.ok) return { visitors: 0, contacts_created: 0, emails_sent: 0, emails_opened: 0, replies: 0, meetings_booked: 0, period: config?.period || "30d" };
+      const data = await resp.json();
+      return data.data || data;
+    }
+  };
+};
+
+// src/voice.ts
+var DEFAULT_API12 = "https://be.graph8.com";
+var createVoiceClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API12;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    /** Start an AI voice session. */
+    async start(config) {
+      const resp = await fetch(`${baseUrl}/api/v1/voice/sessions`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(config)
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Get call analysis for a completed session. */
+    async analysis(sessionId) {
+      const resp = await fetch(`${baseUrl}/api/v1/voice/sessions/${sessionId}/analysis`, { headers: headers() });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Listen for voice events. */
+    on(event, callback) {
+      if (!listeners.has(event)) listeners.set(event, []);
+      listeners.get(event).push(callback);
+    }
+  };
+};
+
+// src/pages.ts
+var DEFAULT_API13 = "https://be.graph8.com";
+var createPagesClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API13;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  return {
+    /** Clone a landing page from any URL. */
+    async clone(url) {
+      const resp = await fetch(`${baseUrl}/api/v1/landing-pages/clone-url`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ url })
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Create a landing page from a template. */
+    async create(config) {
+      const resp = await fetch(`${baseUrl}/api/v1/landing-pages`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(config)
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Publish a landing page to CDN. */
+    async publish(pageId) {
+      const resp = await fetch(`${baseUrl}/api/v1/landing-pages/${pageId}/publish`, {
+        method: "POST",
+        headers: headers()
+      });
+      const data = await resp.json();
+      return { url: data.published_url || data.data?.published_url || "" };
+    }
+  };
+};
+
+// src/webhooks.ts
+var DEFAULT_API14 = "https://be.graph8.com";
+var createWebhooksClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API14;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  const listeners = /* @__PURE__ */ new Map();
+  let polling = false;
+  let pollInterval = null;
+  return {
+    /** Register a listener for a webhook event. Starts polling automatically. */
+    on(event, callback) {
+      if (!listeners.has(event)) listeners.set(event, []);
+      listeners.get(event).push(callback);
+      if (!polling) {
+        polling = true;
+        pollInterval = setInterval(async () => {
+          try {
+            const resp = await fetch(`${baseUrl}/api/v1/webhooks/events?since=30s`, { headers: headers() });
+            if (!resp.ok) return;
+            const data = await resp.json();
+            const events = data.data || data || [];
+            for (const evt of events) {
+              const cbs = listeners.get(evt.type);
+              if (cbs) cbs.forEach((cb) => cb(evt));
+            }
+          } catch {
+          }
+        }, 3e4);
+      }
+    },
+    /** Stop all webhook polling. */
+    stop() {
+      if (pollInterval) clearInterval(pollInterval);
+      polling = false;
+      listeners.clear();
+    }
+  };
+};
+
+// src/contacts.ts
+var DEFAULT_API15 = "https://be.graph8.com";
+var createContactsClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API15;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  const toQuery = (params) => {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v != null) qs.set(k, String(v));
+    }
+    const s = qs.toString();
+    return s ? `?${s}` : "";
+  };
+  return {
+    /** List contacts with optional filters. */
+    async list(params = {}) {
+      const resp = await fetch(`${baseUrl}/api/v1/contacts${toQuery(params)}`, { headers: headers() });
+      return resp.json();
+    },
+    /** Get a single contact by ID. */
+    async get(contactId) {
+      const resp = await fetch(`${baseUrl}/api/v1/contacts/${contactId}`, { headers: headers() });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Create a new contact. */
+    async create(contact) {
+      const resp = await fetch(`${baseUrl}/api/v1/contacts`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(contact)
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Update a contact (partial). */
+    async update(contactId, fields) {
+      const resp = await fetch(`${baseUrl}/api/v1/contacts/${contactId}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify(fields)
+      });
+      return resp.json();
+    },
+    /** Delete a contact (soft-delete). */
+    async delete(contactId) {
+      const resp = await fetch(`${baseUrl}/api/v1/contacts/${contactId}`, {
+        method: "DELETE",
+        headers: headers()
+      });
+      return resp.json();
+    }
+  };
+};
+
+// src/companies.ts
+var DEFAULT_API16 = "https://be.graph8.com";
+var createCompaniesClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API16;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  const toQuery = (params) => {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v != null) qs.set(k, String(v));
+    }
+    const s = qs.toString();
+    return s ? `?${s}` : "";
+  };
+  return {
+    /** List companies with optional filters. */
+    async list(params = {}) {
+      const resp = await fetch(`${baseUrl}/api/v1/companies${toQuery(params)}`, { headers: headers() });
+      return resp.json();
+    },
+    /** Get a single company by ID. */
+    async get(companyId) {
+      const resp = await fetch(`${baseUrl}/api/v1/companies/${companyId}`, { headers: headers() });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Get contacts belonging to a company. */
+    async contacts(companyId, limit = 50, offset = 0) {
+      const resp = await fetch(
+        `${baseUrl}/api/v1/companies/${companyId}/contacts?limit=${limit}&offset=${offset}`,
+        { headers: headers() }
+      );
+      return resp.json();
+    },
+    /** Update a company (partial). */
+    async update(companyId, fields) {
+      const resp = await fetch(`${baseUrl}/api/v1/companies/${companyId}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify(fields)
+      });
+      return resp.json();
+    },
+    /** Delete a company (soft-delete). */
+    async delete(companyId) {
+      const resp = await fetch(`${baseUrl}/api/v1/companies/${companyId}`, {
+        method: "DELETE",
+        headers: headers()
+      });
+      return resp.json();
+    }
+  };
+};
+
+// src/lists.ts
+var DEFAULT_API17 = "https://be.graph8.com";
+var createListsClient = (apiKey, apiUrl) => {
+  const baseUrl = apiUrl || DEFAULT_API17;
+  const headers = () => ({ "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` });
+  return {
+    /** List all lists. */
+    async list(page = 1, limit = 50) {
+      const resp = await fetch(`${baseUrl}/api/v1/lists?page=${page}&limit=${limit}`, { headers: headers() });
+      return resp.json();
+    },
+    /** Create a new list. */
+    async create(title, type = "contacts") {
+      const resp = await fetch(`${baseUrl}/api/v1/lists`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ title, type })
+      });
+      const data = await resp.json();
+      return data.data || data;
+    },
+    /** Delete a list (soft-delete). */
+    async delete(listId) {
+      const resp = await fetch(`${baseUrl}/api/v1/lists/${listId}`, {
+        method: "DELETE",
+        headers: headers()
+      });
+      return resp.json();
+    },
+    /** Get contacts in a list. */
+    async contacts(listId, page = 1, limit = 50) {
+      const resp = await fetch(
+        `${baseUrl}/api/v1/lists/${listId}/contacts?page=${page}&limit=${limit}`,
+        { headers: headers() }
+      );
+      return resp.json();
+    },
+    /** Add contacts to a list. */
+    async addContacts(listId, contactIds) {
+      const resp = await fetch(`${baseUrl}/api/v1/lists/${listId}/contacts`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ contact_ids: contactIds })
+      });
+      return resp.json();
+    },
+    /** Remove contacts from a list. */
+    async removeContacts(listId, contactIds) {
+      const resp = await fetch(`${baseUrl}/api/v1/lists/${listId}/contacts`, {
+        method: "DELETE",
+        headers: headers(),
+        body: JSON.stringify({ contact_ids: contactIds })
+      });
+      return resp.json();
+    }
+  };
+};
+
+// src/core.ts
+var DEFAULT_HOST = "https://t.graph8.com";
+var DEFAULT_API18 = "https://be.graph8.com";
+var G8 = class {
+  constructor() {
+    /** @internal */
+    this.client = null;
+    /** @internal */
+    this.config = null;
+    /** @internal */
+    this._forms = null;
+    /** @internal */
+    this._visitors = null;
+    /** @internal */
+    this._copilot = null;
+    /** @internal */
+    this._chat = null;
+    /** @internal */
+    this._calendar = null;
+    /** @internal */
+    this._enrich = null;
+    /** @internal */
+    this._sequences = null;
+    /** @internal */
+    this._campaigns = null;
+    /** @internal */
+    this._integrations = null;
+    /** @internal */
+    this._signals = null;
+    /** @internal */
+    this._analytics = null;
+    /** @internal */
+    this._voice = null;
+    /** @internal */
+    this._pages = null;
+    /** @internal */
+    this._webhooks = null;
+    /** @internal */
+    this._contacts = null;
+    /** @internal */
+    this._companies = null;
+    /** @internal */
+    this._lists = null;
+  }
+  /**
+   * Initialize the graph8 SDK. Must be called before any other method.
+   * Safe to call on the server (SSR) - becomes a no-op for tracking.
+   */
+  init(config) {
+    this.config = config;
+    if (!isServer) {
+      this.client = jitsuAnalytics({
+        host: config.host || DEFAULT_HOST,
+        writeKey: config.writeKey || "",
+        debug: config.debug
+      });
+    }
+    const apiUrl = config.apiUrl || DEFAULT_API18;
+    const writeKey = config.writeKey || "";
+    const apiKey = config.apiKey || "";
+    if (writeKey) {
+      this._forms = createFormsClient(writeKey, apiUrl);
+      this._visitors = createVisitorsClient(writeKey, apiUrl);
+      this._copilot = createCopilotClient(writeKey, apiUrl);
+      this._chat = createChatClient(writeKey, apiUrl);
+      this._calendar = createCalendarClient(apiUrl);
+      this._signals = createSignalsClient(writeKey, false, apiUrl);
+    }
+    if (apiKey) {
+      this._enrich = createEnrichClient(apiKey, apiUrl);
+      this._sequences = createSequencesClient(apiKey, apiUrl);
+      this._campaigns = createCampaignsClient(apiKey, apiUrl);
+      this._integrations = createIntegrationsClient(apiKey, apiUrl);
+      this._analytics = createAnalyticsClient(apiKey, apiUrl);
+      this._voice = createVoiceClient(apiKey, apiUrl);
+      this._pages = createPagesClient(apiKey, apiUrl);
+      this._webhooks = createWebhooksClient(apiKey, apiUrl);
+      this._contacts = createContactsClient(apiKey, apiUrl);
+      this._companies = createCompaniesClient(apiKey, apiUrl);
+      this._lists = createListsClient(apiKey, apiUrl);
+      this._signals = createSignalsClient(apiKey, true, apiUrl);
+    }
+  }
+  // -- Core tracking (via Jitsu) --
+  /** Track a custom event. */
+  track(event, properties) {
+    this.client?.track(event, properties);
+  }
+  /** Identify a user with properties. */
+  identify(userId, properties) {
+    this.client?.identify(userId, properties);
+  }
+  /** Track a page view. */
+  page(properties) {
+    this.client?.page(properties);
+  }
+  /** Clear user identity (on logout). */
+  reset() {
+    this.client?.reset();
+  }
+  // -- Module accessors --
+  /** Progressive form helpers. */
+  get forms() {
+    this._assertInit();
+    return this._forms;
+  }
+  /** Visitor intelligence - IP to company, engagement scoring. */
+  get visitors() {
+    this._assertInit();
+    return this._visitors;
+  }
+  /** AI copilot widget. */
+  get copilot() {
+    this._assertInit();
+    return this._copilot;
+  }
+  /** Webchat widget. */
+  get chat() {
+    this._assertInit();
+    return this._chat;
+  }
+  /** Calendar and booking. */
+  get calendar() {
+    this._assertInit();
+    return this._calendar;
+  }
+  /** Enrichment API (requires API key). */
+  get enrich() {
+    this._assertKey("enrich");
+    return this._enrich;
+  }
+  /** Sequences (requires API key). */
+  get sequences() {
+    this._assertKey("sequences");
+    return this._sequences;
+  }
+  /** Campaigns (requires API key). */
+  get campaigns() {
+    this._assertKey("campaigns");
+    return this._campaigns;
+  }
+  /** CRM integrations (requires API key). */
+  get integrations() {
+    this._assertKey("integrations");
+    return this._integrations;
+  }
+  /** Intent signals. */
+  get signals() {
+    this._assertInit();
+    return this._signals;
+  }
+  /** Analytics (requires API key). */
+  get analytics() {
+    this._assertKey("analytics");
+    return this._analytics;
+  }
+  /** Voice AI (requires API key). */
+  get voice() {
+    this._assertKey("voice");
+    return this._voice;
+  }
+  /** Landing pages (requires API key). */
+  get pages() {
+    this._assertKey("pages");
+    return this._pages;
+  }
+  /** Webhook event listeners (requires API key). */
+  get webhooks() {
+    this._assertKey("webhooks");
+    return this._webhooks;
+  }
+  /** Contacts CRUD (requires API key). */
+  get contacts() {
+    this._assertKey("contacts");
+    return this._contacts;
+  }
+  /** Companies CRUD (requires API key). */
+  get companies() {
+    this._assertKey("companies");
+    return this._companies;
+  }
+  /** Lists management (requires API key). */
+  get lists() {
+    this._assertKey("lists");
+    return this._lists;
+  }
+  /** Whether the SDK has been initialized. */
+  get initialized() {
+    return this.config !== null;
+  }
+  /** @internal */
+  _assertInit() {
+    if (!this.config) throw new Error("g8.init() must be called first");
+  }
+  /** @internal */
+  _assertKey(module) {
+    this._assertInit();
+    if (!this.config.apiKey) throw new Error(`g8.${module} requires an API key. Use g8.init({ apiKey: '...' })`);
+  }
+};
+var g8 = new G8();
+
+// src/react.tsx
+import { jsx } from "react/jsx-runtime";
+var G8Context = createContext(g8);
+var G8Provider = ({
+  writeKey,
+  host,
+  config,
+  children
+}) => {
+  useEffect(() => {
+    if (!g8.initialized) {
+      g8.init({ writeKey, host, ...config });
+    }
+  }, [writeKey, host, config]);
+  return /* @__PURE__ */ jsx(G8Context.Provider, { value: g8, children });
+};
+var useG8 = () => {
+  const client = useContext(G8Context);
+  return {
+    /** Track a custom event */
+    track: client.track.bind(client),
+    /** Identify a user */
+    identify: client.identify.bind(client),
+    /** Track a page view */
+    page: client.page.bind(client),
+    /** Clear user identity */
+    reset: client.reset.bind(client),
+    /** Progressive form helpers */
+    forms: client.forms,
+    /** Raw g8 client instance */
+    g8: client
+  };
+};
+export {
+  G8Provider,
+  useG8
+};
+//# sourceMappingURL=react.mjs.map