@akropolys/sdk 1.0.0

package/dist/commerce.js

@@ -0,0 +1,1171 @@
+'use client';
+"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/commerce.ts
+var commerce_exports = {};
+__export(commerce_exports, {
+  AkropolysAPI: () => AkropolysAPI,
+  AkropolysClient: () => AkropolysClient,
+  AkropolysProvider: () => AkropolysProvider,
+  KikuStream: () => KikuStream,
+  getAkropolysClient: () => getAkropolysClient,
+  initAkropolys: () => initAkropolys,
+  setSDKDefaultVertical: () => setSDKDefaultVertical,
+  useAkropolys: () => useAkropolys,
+  useAkropolysContext: () => useAkropolysContext,
+  useCart: () => useCart,
+  useIngest: () => useIngest,
+  useKiku: () => useKiku,
+  useListIngest: () => useListIngest,
+  usePageIngest: () => usePageIngest,
+  usePaymentPolling: () => usePaymentPolling,
+  useSearch: () => useSearch
+});
+module.exports = __toCommonJS(commerce_exports);
+
+// src/api.ts
+var MAX_RETRIES = 3;
+var RETRY_DELAYS = [500, 1e3, 2e3];
+function log(level, msg, data) {
+  const prefix = "[Akropolys]";
+  if (level === "error") console.error(prefix, msg, data ?? "");
+  else if (level === "warn") console.warn(prefix, msg, data ?? "");
+  else console.log(prefix, msg, data ?? "");
+}
+async function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var AkropolysAPI = class {
+  constructor(apiUrl, siteId, apiToken, getShopperId, getSessionId, vertical) {
+    this.apiUrl = apiUrl;
+    this.siteId = siteId;
+    this.apiToken = apiToken;
+    this.getShopperId = getShopperId;
+    this.getSessionId = getSessionId;
+    this.vertical = vertical;
+  }
+  async post(path, body, attempt = 0) {
+    const url = `${this.apiUrl}${path}`;
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Akropolys-Token": this.apiToken,
+        "X-Akropolys-Site": this.siteId
+      };
+      const shopperId = this.getShopperId?.();
+      if (shopperId) {
+        headers["X-Akropolys-Shopper-Id"] = shopperId;
+      }
+      const sessionId = this.getSessionId?.();
+      if (sessionId) {
+        headers["X-Akropolys-Session-Id"] = sessionId;
+      }
+      if (typeof window !== "undefined") {
+        const phone = localStorage.getItem("akropolys_user_phone");
+        if (phone) {
+          headers["X-Akropolys-Shopper-Phone"] = phone;
+        }
+      }
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        let message = text;
+        try {
+          const parsed = JSON.parse(text);
+          if (parsed && typeof parsed.error === "string") {
+            message = parsed.error;
+          }
+        } catch {
+        }
+        const err = { status: res.status, message };
+        if (res.status >= 400 && res.status < 500) {
+          log("error", `${path} failed [${res.status}]`, text);
+          throw err;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          log("warn", `${path} [${res.status}] retrying (${attempt + 1}/${MAX_RETRIES})...`);
+          await sleep(RETRY_DELAYS[attempt]);
+          return this.post(path, body, attempt + 1);
+        }
+        log("error", `${path} failed after ${MAX_RETRIES} attempts`, err);
+        throw err;
+      }
+      return res.json();
+    } catch (e) {
+      if (e.status === void 0) {
+        if (attempt < MAX_RETRIES - 1) {
+          log("warn", `${path} network error, retrying (${attempt + 1}/${MAX_RETRIES})...`);
+          await sleep(RETRY_DELAYS[attempt]);
+          return this.post(path, body, attempt + 1);
+        }
+        log("error", `${path} unreachable after ${MAX_RETRIES} attempts`);
+      }
+      throw e;
+    }
+  }
+  async ingest(product) {
+    log("info", "ingesting product", product.name);
+    return this.post("/ingest", { siteId: this.siteId, product });
+  }
+  async ingestBatch(products) {
+    log("info", `ingesting batch of ${products.length} products`);
+    return this.post("/ingest/batch", { siteId: this.siteId, products });
+  }
+  async search(query, limit = 10) {
+    log("info", "search query", query);
+    return this.post("/search", { query, siteId: this.siteId, limit });
+  }
+  // Pure vector search — no LLM, instant results.
+  async searchVector(query, limit = 10) {
+    return this.post("/search/vector", { query, siteId: this.siteId, limit });
+  }
+  // Autocomplete — pure in-memory Trie, <1ms, no Upstash call. Only true prefix matches.
+  async searchAutocomplete(query, limit = 8) {
+    return this.post("/search/autocomplete", { query, siteId: this.siteId, limit });
+  }
+  // LLM chat — conversational search with history context.
+  async chat(query, history = []) {
+    log("info", "chat query", query);
+    const path = !this.vertical || this.vertical === "commerce" ? "/chat" : `/chat/${this.vertical}`;
+    return this.post(path, { query, siteId: this.siteId, history });
+  }
+  // Streaming variant — returns the raw fetch Response.
+  // The caller reads body as a ReadableStream of SSE frames.
+  async chatStream(query, history = [], signal) {
+    log("info", "chatStream query", query);
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Akropolys-Token": this.apiToken,
+      "X-Akropolys-Site": this.siteId
+    };
+    const shopperId = this.getShopperId?.();
+    if (shopperId) headers["X-Akropolys-Shopper-Id"] = shopperId;
+    const sessionId = this.getSessionId?.();
+    if (sessionId) headers["X-Akropolys-Session-Id"] = sessionId;
+    if (typeof window !== "undefined") {
+      const phone = localStorage.getItem("akropolys_user_phone");
+      if (phone) headers["X-Akropolys-Shopper-Phone"] = phone;
+    }
+    const path = !this.vertical || this.vertical === "commerce" ? "/chat/stream" : `/chat/stream/${this.vertical}`;
+    const res = await fetch(`${this.apiUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query, siteId: this.siteId, history }),
+      signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Stream request failed: ${res.status}`);
+    }
+    return res;
+  }
+  // --- Cart System ---
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Akropolys-Token": this.apiToken,
+      "X-Akropolys-Site": this.siteId
+    };
+    const shopperId = this.getShopperId?.();
+    if (shopperId) headers["X-Akropolys-Shopper-Id"] = shopperId;
+    const sessionId = this.getSessionId?.();
+    if (sessionId) headers["X-Akropolys-Session-Id"] = sessionId;
+    if (typeof window !== "undefined") {
+      const phone = localStorage.getItem("akropolys_user_phone");
+      if (phone) {
+        headers["X-Akropolys-Shopper-Phone"] = phone;
+      }
+    }
+    return headers;
+  }
+  async getCart() {
+    const res = await fetch(`${this.apiUrl}/cart?siteId=${this.siteId}`, {
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to fetch cart");
+    return res.json();
+  }
+  async clearCart() {
+    const res = await fetch(`${this.apiUrl}/cart?siteId=${this.siteId}`, {
+      method: "DELETE",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to clear cart");
+    return res.json();
+  }
+  async checkoutCart() {
+    const res = await fetch(`${this.apiUrl}/cart/checkout`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify({ siteId: this.siteId })
+    });
+    if (!res.ok) throw new Error("Failed to checkout cart");
+    return res.json();
+  }
+  async getCheckoutConfig() {
+    const res = await fetch(`${this.apiUrl}/checkout/config?site_id=${this.siteId}`, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to fetch checkout config");
+    return res.json();
+  }
+  async initiatePayment(phoneNumber, email, firstName, lastName) {
+    const res = await fetch(`${this.apiUrl}/payment/initiate`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify({
+        siteId: this.siteId,
+        phoneNumber,
+        email,
+        firstName,
+        lastName
+      })
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error("Failed to initiate payment: " + errText);
+    }
+    return res.json();
+  }
+  async getPaymentStatus(ref) {
+    const res = await fetch(`${this.apiUrl}/payment/status?ref=${ref}`, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to get payment status");
+    return res.json();
+  }
+};
+
+// src/stream.ts
+function parseSSEChunk(raw) {
+  const frames = [];
+  const blocks = raw.split(/\n\n+/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    let event = "";
+    let data = "";
+    for (const line of block.split("\n")) {
+      if (line.startsWith("event:")) event = line.slice(6).trim();
+      else if (line.startsWith("data:")) data = line.slice(5);
+    }
+    if (data !== "") frames.push({ event, data });
+  }
+  return frames;
+}
+var KikuStream = class {
+  constructor(responsePromise, abortController) {
+    this.listeners = {};
+    this.aborted = false;
+    this.responsePromise = responsePromise;
+    this.abortController = abortController;
+    this.startReading();
+  }
+  on(event, callback) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(callback);
+    return this;
+  }
+  off(event, callback) {
+    if (!this.listeners[event]) return this;
+    this.listeners[event] = this.listeners[event].filter((cb) => cb !== callback);
+    return this;
+  }
+  destroy() {
+    this.aborted = true;
+    this.abortController.abort();
+  }
+  emit(event, ...args) {
+    const list = this.listeners[event];
+    if (!list) return;
+    for (const cb of list) {
+      try {
+        cb(...args);
+      } catch (err) {
+        console.error(`[Akropolys] Error in KikuStream event listener for "${event}":`, err);
+      }
+    }
+  }
+  async startReading() {
+    try {
+      const response = await this.responsePromise;
+      if (this.aborted) return;
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let accumulatedMessage = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done || this.aborted) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lastBoundary = buffer.lastIndexOf("\n\n");
+        if (lastBoundary === -1) continue;
+        const complete = buffer.slice(0, lastBoundary + 2);
+        buffer = buffer.slice(lastBoundary + 2);
+        const frames = parseSSEChunk(complete);
+        for (const { event, data } of frames) {
+          if (this.aborted) return;
+          if (event === "meta") {
+            try {
+              const meta = JSON.parse(data);
+              this.emit("meta", meta);
+            } catch {
+            }
+            continue;
+          }
+          if (event === "done") {
+            break;
+          }
+          if (event === "error") {
+            let msg = "Stream error";
+            try {
+              msg = JSON.parse(data).error ?? msg;
+            } catch {
+              msg = data;
+            }
+            throw new Error(msg);
+          }
+          const token = data.replace(/\\n/g, "\n");
+          accumulatedMessage += token;
+          this.emit("token", token);
+        }
+      }
+      if (!this.aborted) {
+        this.emit("done", accumulatedMessage);
+      }
+    } catch (err) {
+      if (!this.aborted) {
+        this.emit("error", err);
+      }
+    }
+  }
+};
+
+// src/client.ts
+var import_meta = {};
+var defaultVertical = "commerce";
+function setSDKDefaultVertical(v) {
+  defaultVertical = v;
+}
+function getEnvVar(key) {
+  if (key === "NEXT_PUBLIC_AKROPOLYS_SITE_ID") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_SITE_ID;
+    } catch {
+    }
+  }
+  if (key === "NEXT_PUBLIC_AKROPOLYS_API_URL") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_API_URL;
+    } catch {
+    }
+  }
+  if (key === "NEXT_PUBLIC_AKROPOLYS_API_TOKEN") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_API_TOKEN;
+    } catch {
+    }
+  }
+  try {
+    const metaEnv = import_meta.env;
+    if (metaEnv) {
+      if (key === "NEXT_PUBLIC_AKROPOLYS_SITE_ID") return metaEnv.NEXT_PUBLIC_AKROPOLYS_SITE_ID || metaEnv.VITE_AKROPOLYS_SITE_ID;
+      if (key === "NEXT_PUBLIC_AKROPOLYS_API_URL") return metaEnv.NEXT_PUBLIC_AKROPOLYS_API_URL || metaEnv.VITE_AKROPOLYS_API_URL;
+      if (key === "NEXT_PUBLIC_AKROPOLYS_API_TOKEN") return metaEnv.NEXT_PUBLIC_AKROPOLYS_API_TOKEN || metaEnv.VITE_AKROPOLYS_API_TOKEN;
+    }
+  } catch {
+  }
+  if (typeof globalThis !== "undefined") {
+    const g = globalThis;
+    if (g.process && g.process.env) {
+      return g.process.env[key];
+    }
+  }
+  return void 0;
+}
+function mapRawProduct(input) {
+  const name = input.name || input.title || input.productName || "";
+  let price = "";
+  let priceNumeric = void 0;
+  if (input.price !== void 0) {
+    if (typeof input.price === "number") {
+      priceNumeric = input.price;
+      price = String(input.price);
+    } else {
+      price = input.price;
+      const num = parseFloat(input.price.replace(/[^0-9.]/g, ""));
+      priceNumeric = isNaN(num) ? void 0 : num;
+    }
+  }
+  if (input.priceNumeric !== void 0) {
+    priceNumeric = input.priceNumeric;
+  }
+  let url = input.url || "";
+  if (!url && typeof window !== "undefined") {
+    url = window.location.href;
+  }
+  let slug = input.slug || input.id || input.productId || "";
+  if (!slug && url) {
+    slug = url.split("/").filter(Boolean).pop() || "";
+  }
+  if (!slug && name) {
+    slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+  }
+  let images = [];
+  if (input.images) {
+    images = input.images;
+  } else if (input.image) {
+    images = [input.image];
+  } else if (input.listing_agent_photo) {
+    images = [input.listing_agent_photo];
+  } else if (input.thumbnail) {
+    images = [input.thumbnail];
+  }
+  if (!name) {
+    console.warn("[Akropolys] Validation warning: Product name/title is missing. Skipping:", input);
+    return null;
+  }
+  if (!price) {
+    console.warn("[Akropolys] Validation warning: Product price is missing. Skipping:", input);
+    return null;
+  }
+  if (!url) {
+    console.warn("[Akropolys] Validation warning: Product URL is missing. Skipping:", input);
+    return null;
+  }
+  const coreKeys = /* @__PURE__ */ new Set([
+    "name",
+    "title",
+    "productName",
+    "price",
+    "priceNumeric",
+    "url",
+    "image",
+    "thumbnail",
+    "images",
+    "slug",
+    "id",
+    "productId",
+    "brand",
+    "description",
+    "originalPrice",
+    "discount",
+    "currency",
+    "stock",
+    "availability",
+    "rating",
+    "reviewCount",
+    "category",
+    "subCategory",
+    "tags",
+    "specs",
+    "metadata"
+  ]);
+  const metadata = { ...input.metadata };
+  for (const [key, value] of Object.entries(input)) {
+    if (!coreKeys.has(key) && value !== void 0) {
+      metadata[key] = value;
+    }
+  }
+  return {
+    name,
+    price,
+    url,
+    brand: input.brand,
+    description: input.description,
+    originalPrice: input.originalPrice,
+    discount: input.discount,
+    currency: input.currency ?? "KES",
+    stock: input.stock,
+    availability: input.availability,
+    rating: input.rating,
+    reviewCount: input.reviewCount,
+    category: input.category,
+    subCategory: input.subCategory,
+    tags: input.tags,
+    images: images.length > 0 ? images : void 0,
+    specs: input.specs,
+    priceNumeric,
+    slug,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+  };
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var _AkropolysClient = class _AkropolysClient {
+  constructor(config) {
+    this.ingestQueue = [];
+    this.ingestTimer = null;
+    this.ingestedUrls = /* @__PURE__ */ new Set();
+    this.onlineHandler = null;
+    this.sessionId = "";
+    const siteId = config.siteId || getEnvVar("NEXT_PUBLIC_AKROPOLYS_SITE_ID") || "";
+    const apiUrl = config.apiUrl || getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_URL") || "";
+    const apiToken = config.apiToken || getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_TOKEN") || "";
+    if (!siteId) console.error('[Akropolys] Missing siteId. Set it via <AkropolysProvider siteId="..."> or NEXT_PUBLIC_AKROPOLYS_SITE_ID.');
+    if (!apiUrl) console.error('[Akropolys] Missing apiUrl. Set it via <AkropolysProvider apiUrl="..."> or NEXT_PUBLIC_AKROPOLYS_API_URL.');
+    if (!apiToken) console.error('[Akropolys] Missing apiToken. Set it via <AkropolysProvider apiToken="..."> or NEXT_PUBLIC_AKROPOLYS_API_TOKEN.');
+    this.shopperId = config.shopperId;
+    this.authLoading = config.authLoading;
+    this.onCheckout = config.onCheckout;
+    this.onError = config.onError;
+    this.vertical = config.vertical || defaultVertical;
+    this.initSession();
+    this.loadIngestedCache();
+    this.api = new AkropolysAPI(
+      apiUrl,
+      siteId,
+      apiToken,
+      () => this.getShopperId(),
+      () => this.sessionId,
+      this.vertical
+    );
+    instance = this;
+    if (typeof window !== "undefined") {
+      this.onlineHandler = () => {
+        console.log("[Akropolys] Connectivity restored, flushing queued ingestions.");
+        this.flushQueue();
+      };
+      window.addEventListener("online", this.onlineHandler);
+    }
+  }
+  // 24h
+  loadIngestedCache() {
+    if (typeof window === "undefined") return;
+    try {
+      const raw = localStorage.getItem(_AkropolysClient.INGEST_CACHE_KEY);
+      if (!raw) return;
+      const { ts, urls } = JSON.parse(raw);
+      if (Date.now() - ts > _AkropolysClient.INGEST_CACHE_TTL) {
+        localStorage.removeItem(_AkropolysClient.INGEST_CACHE_KEY);
+        return;
+      }
+      this.ingestedUrls = new Set(urls);
+    } catch {
+    }
+  }
+  saveIngestedCache() {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(
+        _AkropolysClient.INGEST_CACHE_KEY,
+        JSON.stringify({ ts: Date.now(), urls: [...this.ingestedUrls] })
+      );
+    } catch {
+    }
+  }
+  chat(query, history = []) {
+    const abortController = new AbortController();
+    const responsePromise = this.api.chatStream(query, history, abortController.signal);
+    return new KikuStream(responsePromise, abortController);
+  }
+  reRegister() {
+    instance = this;
+  }
+  setShopperId(id) {
+    this.shopperId = id;
+    if (!this.authLoading) {
+      this.flushQueue();
+    }
+  }
+  setAuthLoading(loading) {
+    const wasLoading = this.authLoading;
+    this.authLoading = loading;
+    if (wasLoading && !loading) {
+      this.flushQueue();
+    }
+  }
+  getShopperId() {
+    return this.shopperId || "guest_" + this.sessionId;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  initSession() {
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      try {
+        let sid = window.sessionStorage.getItem("akropolys_session_id");
+        if (!sid) {
+          sid = generateUUID();
+          window.sessionStorage.setItem("akropolys_session_id", sid);
+        }
+        this.sessionId = sid;
+        return;
+      } catch (e) {
+      }
+    }
+    this.sessionId = generateUUID();
+  }
+  destroy() {
+    if (typeof window !== "undefined" && this.onlineHandler) {
+      window.removeEventListener("online", this.onlineHandler);
+      this.onlineHandler = null;
+    }
+    if (this.ingestTimer) {
+      clearTimeout(this.ingestTimer);
+      this.ingestTimer = null;
+    }
+    if (instance === this) instance = null;
+  }
+  async queueIngest(rawProduct) {
+    const product = mapRawProduct(rawProduct);
+    if (!product) return;
+    if (this.ingestedUrls.has(product.url)) {
+      return;
+    }
+    this.ingestedUrls.add(product.url);
+    this.saveIngestedCache();
+    this.ingestQueue.push(product);
+    this.scheduleFlush();
+  }
+  async queueIngestBatch(rawProducts) {
+    rawProducts.forEach((p) => {
+      const product = mapRawProduct(p);
+      if (!product) return;
+      if (this.ingestedUrls.has(product.url)) {
+        return;
+      }
+      this.ingestedUrls.add(product.url);
+      this.ingestQueue.push(product);
+    });
+    if (this.ingestQueue.length > 0) {
+      this.saveIngestedCache();
+      this.scheduleFlush();
+    }
+  }
+  scheduleFlush() {
+    if (this.ingestTimer) return;
+    this.ingestTimer = setTimeout(() => {
+      this.flushQueue();
+    }, 300);
+  }
+  async flushQueue() {
+    this.ingestTimer = null;
+    if (this.ingestQueue.length === 0) return;
+    if (this.authLoading) {
+      console.log("[Akropolys] Authentication is loading. Deferring ingestion flush.");
+      return;
+    }
+    if (typeof navigator !== "undefined" && !navigator.onLine) {
+      console.warn("[Akropolys] Browser offline. Postponing ingestion.");
+      return;
+    }
+    const batch = [...this.ingestQueue];
+    this.ingestQueue = [];
+    try {
+      await this.api.ingestBatch(batch);
+    } catch (e) {
+      const akropolysError = {
+        status: e.status || 500,
+        message: e.message || "Unknown network error"
+      };
+      if (this.onError) {
+        try {
+          this.onError(akropolysError);
+        } catch (err) {
+          console.error("[Akropolys] Error inside onError callback:", err);
+        }
+      }
+      if (e.status && e.status >= 400 && e.status < 500) {
+        console.error("[Akropolys] Ingestion discarded due to client error:", e.message);
+        return;
+      }
+      console.warn("[Akropolys] Ingestion failed. Re-queuing to retry.", e);
+      this.ingestQueue = [...batch, ...this.ingestQueue];
+      this.scheduleFlush();
+    }
+  }
+};
+_AkropolysClient.INGEST_CACHE_KEY = "akropolys_ingested_v2";
+_AkropolysClient.INGEST_CACHE_TTL = 24 * 60 * 60 * 1e3;
+var AkropolysClient = _AkropolysClient;
+var instance = null;
+function initAkropolys(config) {
+  instance = new AkropolysClient(config);
+  return instance;
+}
+function getAkropolysClient() {
+  if (!instance) {
+    const siteId = getEnvVar("NEXT_PUBLIC_AKROPOLYS_SITE_ID");
+    const apiUrl = getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_URL");
+    const apiToken = getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_TOKEN");
+    if (siteId && apiUrl && apiToken) {
+      instance = new AkropolysClient({ siteId, apiUrl, apiToken });
+    } else {
+      throw new Error("[Akropolys] Call initAkropolys() or set NEXT_PUBLIC_AKROPOLYS_* environment variables before using the client.");
+    }
+  }
+  return instance;
+}
+
+// src/Provider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var AkropolysContext = (0, import_react.createContext)(null);
+function AkropolysProvider({
+  siteId,
+  apiUrl,
+  apiToken,
+  shopperId,
+  vertical,
+  authLoading,
+  onCheckout,
+  onError,
+  children
+}) {
+  const clientRef = (0, import_react.useRef)(null);
+  if (!clientRef.current) {
+    clientRef.current = new AkropolysClient({
+      siteId,
+      apiUrl,
+      apiToken,
+      shopperId,
+      vertical,
+      authLoading,
+      onCheckout,
+      onError
+    });
+  } else {
+    clientRef.current.reRegister();
+  }
+  (0, import_react.useEffect)(() => {
+    clientRef.current?.setShopperId(shopperId);
+  }, [shopperId]);
+  (0, import_react.useEffect)(() => {
+    clientRef.current?.setAuthLoading(!!authLoading);
+  }, [authLoading]);
+  (0, import_react.useEffect)(() => {
+    if (clientRef.current) {
+      clientRef.current.onError = onError;
+      clientRef.current.onCheckout = onCheckout;
+    }
+  }, [onError, onCheckout]);
+  (0, import_react.useEffect)(() => {
+    clientRef.current?.reRegister();
+  }, []);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      clientRef.current?.destroy();
+    };
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AkropolysContext.Provider, { value: clientRef.current, children });
+}
+function useAkropolysContext() {
+  const context = (0, import_react.useContext)(AkropolysContext);
+  if (!context) {
+    return getAkropolysClient();
+  }
+  return context;
+}
+
+// src/hooks/useAkropolys.ts
+var import_react2 = require("react");
+function useAkropolys(config) {
+  const clientRef = (0, import_react2.useRef)(null);
+  if (!clientRef.current) {
+    console.warn("[Akropolys] useAkropolys() is deprecated. Please wrap your application in <AkropolysProvider> instead.");
+    clientRef.current = initAkropolys(config);
+  }
+  return clientRef.current;
+}
+
+// src/hooks/useSearch.ts
+var import_react3 = require("react");
+function useSearch() {
+  const client = useAkropolysContext();
+  const [results, setResults] = (0, import_react3.useState)([]);
+  const [loading, setLoading] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const genRef = (0, import_react3.useRef)(0);
+  const search = (0, import_react3.useCallback)(async (query, limit = 8) => {
+    if (!query.trim()) {
+      setResults([]);
+      setLoading(false);
+      return;
+    }
+    const gen = ++genRef.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await client.api.searchAutocomplete(query, limit);
+      if (gen === genRef.current) {
+        setResults(res.results ?? []);
+      }
+    } catch (e) {
+      if (gen === genRef.current) {
+        let msg = e?.message ?? "Search failed";
+        try {
+          const parsed = JSON.parse(msg);
+          if (parsed && parsed.error) {
+            msg = parsed.error;
+          }
+        } catch {
+        }
+        setError(msg);
+      }
+    } finally {
+      if (gen === genRef.current) setLoading(false);
+    }
+  }, [client]);
+  const clear = (0, import_react3.useCallback)(() => {
+    genRef.current++;
+    setResults([]);
+    setError(null);
+    setLoading(false);
+  }, []);
+  return { results, loading, error, search, clear };
+}
+
+// src/hooks/useIngest.ts
+var import_react4 = require("react");
+var recentlyIngested = /* @__PURE__ */ new Set();
+function getProductKey(p) {
+  return p.url || p.id || p.productId || p.slug || p.name || p.title || p.productName || null;
+}
+function useIngest() {
+  const client = useAkropolysContext();
+  const ingest = (0, import_react4.useCallback)((product) => {
+    const key = getProductKey(product);
+    if (key) {
+      if (recentlyIngested.has(key)) return;
+      recentlyIngested.add(key);
+    }
+    client.queueIngest(product).catch(() => {
+    });
+  }, [client]);
+  const ingestBatch = (0, import_react4.useCallback)((products) => {
+    const toIngest = products.filter((p) => {
+      const key = getProductKey(p);
+      if (!key) return true;
+      if (recentlyIngested.has(key)) return false;
+      recentlyIngested.add(key);
+      return true;
+    });
+    if (!toIngest.length) return;
+    client.queueIngestBatch(toIngest).catch(() => {
+    });
+  }, [client]);
+  return { ingest, ingestBatch, loading: false, error: null };
+}
+
+// src/hooks/useListIngest.ts
+var import_react5 = require("react");
+function useListIngest(products) {
+  const { ingestBatch } = useIngest();
+  const processedIdsRef = (0, import_react5.useRef)(/* @__PURE__ */ new Set());
+  const listKey = (products || []).map((p) => p.url || p.id || p.productId || p.slug || p.name || p.title || p.productName || "").join(",");
+  (0, import_react5.useEffect)(() => {
+    if (!products || !products.length) return;
+    const newItems = products.filter((item) => {
+      const id = item.id || item.productId || item.url || item.slug || item.name || item.title || item.productName;
+      if (!id) return true;
+      if (processedIdsRef.current.has(id)) {
+        return false;
+      }
+      processedIdsRef.current.add(id);
+      return true;
+    });
+    if (newItems.length > 0) {
+      ingestBatch(newItems);
+    }
+  }, [listKey, ingestBatch]);
+}
+
+// src/hooks/usePageIngest.ts
+var import_react6 = require("react");
+function usePageIngest(product) {
+  const ingestedRef = (0, import_react6.useRef)(null);
+  (0, import_react6.useEffect)(() => {
+    if (!product) return;
+    const url = product.url || (typeof window !== "undefined" ? window.location.href : "");
+    if (ingestedRef.current === url) return;
+    ingestedRef.current = url;
+    try {
+      getAkropolysClient().queueIngest({ ...product, url });
+    } catch {
+    }
+  }, [product?.url ?? product?.name]);
+}
+
+// src/hooks/useKiku.ts
+var import_react7 = require("react");
+function useKiku(options = {}) {
+  const client = useAkropolysContext();
+  const [messages, setMessages] = (0, import_react7.useState)(options.initialMessages ?? []);
+  const [sources, setSources] = (0, import_react7.useState)([]);
+  const [loading, setLoading] = (0, import_react7.useState)(false);
+  const [streaming, setStreaming] = (0, import_react7.useState)(false);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const [lastAction, setLastAction] = (0, import_react7.useState)(null);
+  const [lastIntent, setLastIntent] = (0, import_react7.useState)(null);
+  const activeStreamRef = (0, import_react7.useRef)(null);
+  const onTokenRef = (0, import_react7.useRef)(options.onToken);
+  const onMetaRef = (0, import_react7.useRef)(options.onMeta);
+  const onDoneRef = (0, import_react7.useRef)(options.onDone);
+  const onErrorRef = (0, import_react7.useRef)(options.onError);
+  (0, import_react7.useEffect)(() => {
+    onTokenRef.current = options.onToken;
+    onMetaRef.current = options.onMeta;
+    onDoneRef.current = options.onDone;
+    onErrorRef.current = options.onError;
+  }, [options.onToken, options.onMeta, options.onDone, options.onError]);
+  (0, import_react7.useEffect)(() => {
+    return () => {
+      activeStreamRef.current?.destroy();
+    };
+  }, []);
+  const send = (0, import_react7.useCallback)(async (query, displayQuery) => {
+    if (!query.trim() || loading) return;
+    activeStreamRef.current?.destroy();
+    const userMsg = { role: "user", content: displayQuery ?? query };
+    setMessages((prev) => [...prev, userMsg]);
+    setLoading(true);
+    setStreaming(false);
+    setError(null);
+    try {
+      const history = messages.map((m) => ({ role: m.role, content: m.content }));
+      const stream = client.chat(query, history);
+      activeStreamRef.current = stream;
+      let messageInitialized = false;
+      let lastMeta = null;
+      stream.on("meta", (meta) => {
+        lastMeta = meta;
+        setSources(meta.sources ?? []);
+        if (meta.intent) setLastIntent(meta.intent);
+        if (meta.action) setLastAction(meta.action);
+        onMetaRef.current?.(meta);
+      });
+      stream.on("token", (token) => {
+        if (!messageInitialized) {
+          setLoading(false);
+          setStreaming(true);
+          setMessages((prev) => [...prev, { role: "assistant", content: token }]);
+          messageInitialized = true;
+        } else {
+          setMessages((prev) => {
+            const next = [...prev];
+            if (next.length > 0 && next[next.length - 1].role === "assistant") {
+              next[next.length - 1] = {
+                ...next[next.length - 1],
+                content: next[next.length - 1].content + token
+              };
+            }
+            return next;
+          });
+        }
+        onTokenRef.current?.(token);
+      });
+      stream.on("done", (fullMessage) => {
+        setLoading(false);
+        setStreaming(false);
+        const metaAction = lastMeta?.action;
+        const metaCheckout = lastMeta?.checkout;
+        const isCartAction = metaAction?.type === "add_to_cart" || metaAction?.type === "remove_from_cart" || metaAction?.type === "clear_cart" || metaAction?.type === "view_cart";
+        if (isCartAction || metaCheckout) {
+          setMessages((prev) => {
+            const next = [...prev];
+            if (next.length > 0 && next[next.length - 1].role === "assistant") {
+              next[next.length - 1] = {
+                ...next[next.length - 1],
+                cartSnapshot: metaCheckout,
+                actionType: metaAction?.type
+              };
+            }
+            return next;
+          });
+          window.dispatchEvent(new CustomEvent("akropolys:cart_updated", { detail: metaCheckout }));
+        }
+        if (metaAction?.type === "checkout") {
+          window.dispatchEvent(new CustomEvent("akropolys:trigger_checkout", { detail: metaCheckout }));
+        }
+        if (metaAction?.type === "awaiting_payment") {
+          window.dispatchEvent(new CustomEvent("akropolys:awaiting_payment", { detail: metaAction }));
+        }
+        if (metaCheckout && client.onCheckout) {
+          client.onCheckout(metaCheckout);
+        }
+        onDoneRef.current?.(fullMessage);
+      });
+      stream.on("error", (err) => {
+        setLoading(false);
+        setStreaming(false);
+        setError(err.message);
+        setMessages((prev) => prev.slice(0, -1));
+        onErrorRef.current?.(err);
+      });
+    } catch (err) {
+      setLoading(false);
+      setStreaming(false);
+      setError(err?.message ?? "Chat request failed");
+      setMessages((prev) => prev.slice(0, -1));
+      onErrorRef.current?.(err);
+    }
+  }, [client, messages, loading]);
+  const reset = (0, import_react7.useCallback)(() => {
+    activeStreamRef.current?.destroy();
+    setMessages([]);
+    setSources([]);
+    setStreaming(false);
+    setError(null);
+    setLoading(false);
+    setLastAction(null);
+    setLastIntent(null);
+  }, []);
+  return { messages, sources, loading, streaming, error, lastAction, lastIntent, send, reset };
+}
+
+// src/hooks/useCart.ts
+var import_react8 = require("react");
+function useCart() {
+  const client = useAkropolysContext();
+  const [cart, setCart] = (0, import_react8.useState)(null);
+  const [loading, setLoading] = (0, import_react8.useState)(false);
+  const shopperId = client.getShopperId();
+  const fetchCart = (0, import_react8.useCallback)(async () => {
+    if (!shopperId) return;
+    setLoading(true);
+    try {
+      const res = await client.api.getCart();
+      setCart(res);
+    } catch (e) {
+      console.error("[Akropolys] Failed to fetch cart", e);
+    } finally {
+      setLoading(false);
+    }
+  }, [client, shopperId]);
+  (0, import_react8.useEffect)(() => {
+    fetchCart();
+    const handleCartUpdate = (e) => {
+      if (e.detail) {
+        setCart(e.detail);
+      } else {
+        fetchCart();
+      }
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("akropolys:cart_updated", handleCartUpdate);
+      return () => window.removeEventListener("akropolys:cart_updated", handleCartUpdate);
+    }
+  }, [fetchCart, shopperId]);
+  return { cart, loading, fetchCart };
+}
+
+// src/hooks/usePaymentPolling.ts
+var import_react9 = require("react");
+function usePaymentPolling({
+  client,
+  merchantReference,
+  onSuccess,
+  onFailure,
+  intervalMs = 3e3,
+  timeoutMs = 3e5
+  // 5 minutes default
+}) {
+  const [status, setStatus] = (0, import_react9.useState)("IDLE");
+  const [error, setError] = (0, import_react9.useState)(null);
+  const onSuccessRef = (0, import_react9.useRef)(onSuccess);
+  const onFailureRef = (0, import_react9.useRef)(onFailure);
+  (0, import_react9.useEffect)(() => {
+    onSuccessRef.current = onSuccess;
+    onFailureRef.current = onFailure;
+  }, [onSuccess, onFailure]);
+  (0, import_react9.useEffect)(() => {
+    if (!merchantReference) {
+      setStatus("IDLE");
+      setError(null);
+      return;
+    }
+    setStatus("PENDING");
+    setError(null);
+    const startTime = Date.now();
+    let timerId = null;
+    async function checkStatus() {
+      try {
+        if (Date.now() - startTime >= timeoutMs) {
+          setStatus("FAILED");
+          setError("Payment session timed out");
+          if (onFailureRef.current) onFailureRef.current("Payment session timed out");
+          return;
+        }
+        const res = await client.getPaymentStatus(merchantReference);
+        if (res.status === "COMPLETED") {
+          setStatus("COMPLETED");
+          if (onSuccessRef.current) onSuccessRef.current();
+        } else if (res.status === "FAILED") {
+          setStatus("FAILED");
+          setError("Payment failed");
+          if (onFailureRef.current) onFailureRef.current("Payment failed");
+        } else {
+          timerId = setTimeout(checkStatus, intervalMs);
+        }
+      } catch (err) {
+        console.error("[Akropolys Polling Error]", err);
+        timerId = setTimeout(checkStatus, intervalMs);
+      }
+    }
+    timerId = setTimeout(checkStatus, intervalMs);
+    return () => {
+      if (timerId) {
+        clearTimeout(timerId);
+      }
+    };
+  }, [client, merchantReference, intervalMs, timeoutMs]);
+  return { status, error };
+}
+
+// src/commerce.ts
+setSDKDefaultVertical("commerce");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AkropolysAPI,
+  AkropolysClient,
+  AkropolysProvider,
+  KikuStream,
+  getAkropolysClient,
+  initAkropolys,
+  setSDKDefaultVertical,
+  useAkropolys,
+  useAkropolysContext,
+  useCart,
+  useIngest,
+  useKiku,
+  useListIngest,
+  usePageIngest,
+  usePaymentPolling,
+  useSearch
+});
+//# sourceMappingURL=commerce.js.map