@fruga/sdk 1.0.2 → 1.3.0

package/dist/index.mjs

@@ -1,3 +1,7 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
 // packages/core/src/domain/entities/Theme.ts
 var DEFAULT_THEME = {
   widgetTitle: "Savings Box",
@@ -51,50 +55,51 @@ function getResolvedTheme(theme) {
   };
 }
 
-// packages/core/src/infrastructure/adapters/HttpWalletService.ts
-var HttpWalletService = class {
-  constructor(baseUrl, token) {
-    this.baseUrl = baseUrl;
-    this.token = token;
+// packages/core/src/domain/entities/Messages.ts
+var PROTOCOL_VERSION = "1.0";
+var MESSAGE_TYPES = [
+  "NEED_TOKEN",
+  "FRUGA_TOKEN_UPDATE",
+  "FRUGA_GET_BALANCE",
+  "FRUGA_BALANCE_RESPONSE",
+  "FRUGA_RESIZE",
+  "FRUGA_HOST_RESIZE",
+  "FRUGA_READY",
+  "FRUGA_INIT"
+];
+var isFrugaMessageType = (value) => typeof value === "string" && MESSAGE_TYPES.includes(value);
+var NEED_TOKEN_REASONS = ["ttl", "unauthorized"];
+var isFrugaMessage = (data) => {
+  if (typeof data !== "object" || data === null) return false;
+  const candidate = data;
+  if (!isFrugaMessageType(candidate.type)) return false;
+  if (candidate.version !== void 0 && typeof candidate.version !== "string") return false;
+  if (candidate.type === "NEED_TOKEN") {
+    const { reason } = data;
+    return typeof reason === "string" && NEED_TOKEN_REASONS.includes(reason);
   }
-  async getWallet() {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/wallet`, {
-        method: "GET",
-        headers: {
-          "Accept": "application/json",
-          "Authorization": `Bearer ${this.token}`
-        }
-      });
-      if (!response.ok) {
-        console.warn(`[FrugaSDK] Failed to fetch wallet: ${response.status}. Returning zeroed wallet.`);
-        return this.getEmptyWallet();
-      }
-      const data = await response.json();
-      return {
-        available: data.available ?? 0,
-        pending: data.pending ?? 0,
-        totalBalance: (data.available || 0) + (data.pending || 0),
-        lifetimeEarned: data.lifetimeEarned ?? 0,
-        lifetimeRedeemed: data.lifetimeRedeemed ?? 0,
-        updatedAt: data.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-        requiredActions: data.requiredActions ?? null
-      };
-    } catch (error) {
-      console.warn(`[FrugaSDK] Network error fetching wallet. Returning zeroed wallet.`, error);
-      return this.getEmptyWallet();
-    }
+  return true;
+};
+var protocolMajor = (v) => Number.parseInt(v.split(".")[0] ?? "", 10);
+
+// packages/core/src/domain/entities/Constants.ts
+var HOST_MOBILE_BREAKPOINT = 768;
+
+// packages/core/src/domain/entities/index.ts
+var resolvePayoutMode = (value) => value === "PARTNER" || value === "USER" ? value : null;
+
+// packages/core/src/domain/errors/HttpError.ts
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
   }
-  getEmptyWallet() {
-    return {
-      available: 0,
-      pending: 0,
-      totalBalance: 0,
-      lifetimeEarned: 0,
-      lifetimeRedeemed: 0,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      requiredActions: null
-    };
+};
+var UnauthorizedError = class extends HttpError {
+  constructor(message = "Unauthorized") {
+    super(401, message);
+    this.name = "UnauthorizedError";
   }
 };
 
@@ -124,6 +129,41 @@ var BaseHttpService = class {
     });
   }
 };
+var assertOk = (response, context) => {
+  if (response.ok) return;
+  if (response.status === 401) {
+    throw new UnauthorizedError(`${context}: unauthorized`);
+  }
+  throw new HttpError(response.status, `${context}: ${response.status}`);
+};
+
+// packages/core/src/infrastructure/adapters/HttpWalletService.ts
+var HttpWalletService = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  async getWallet() {
+    const response = await fetch(`${this.baseUrl}/api/wallet`, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "Authorization": `Bearer ${this.token}`
+      }
+    });
+    assertOk(response, "Failed to fetch wallet");
+    const data = await response.json();
+    return {
+      available: data.available ?? 0,
+      pending: data.pending ?? 0,
+      totalBalance: (data.available || 0) + (data.pending || 0),
+      lifetimeEarned: data.lifetimeEarned ?? 0,
+      lifetimeRedeemed: data.lifetimeRedeemed ?? 0,
+      updatedAt: data.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      requiredActions: data.requiredActions ?? null
+    };
+  }
+};
 
 // packages/core/src/infrastructure/adapters/HttpActivityService.ts
 var HttpActivityService = class extends BaseHttpService {
@@ -131,27 +171,12 @@ var HttpActivityService = class extends BaseHttpService {
     super(baseUrl, token);
   }
   async getActivity(pageNumber, pageSize) {
-    try {
-      const response = await this.fetchQuery("/api/activity", { pageNumber, pageSize });
-      if (!response.ok) {
-        console.warn(`[FrugaSDK] Failed to fetch activity: ${response.status}. Returning empty activity.`);
-        return this.getEmptyActivity();
-      }
-      const data = await response.json();
-      return {
-        ...data,
-        transactions: data.transactions || []
-      };
-    } catch (error) {
-      console.warn(`[FrugaSDK] Network error fetching activity. Returning empty activity.`, error);
-      return this.getEmptyActivity();
-    }
-  }
-  getEmptyActivity() {
+    const response = await this.fetchQuery("/api/activity", { pageNumber, pageSize });
+    assertOk(response, "Failed to fetch activity");
+    const data = await response.json();
     return {
-      actorType: "",
-      partnerId: 0,
-      transactions: []
+      ...data,
+      transactions: data.transactions || []
     };
   }
 };
@@ -162,53 +187,25 @@ var HttpOffersService = class extends BaseHttpService {
     super(baseUrl, token);
   }
   async getCategories() {
-    try {
-      const response = await this.fetchQuery("/api/offers/categories");
-      if (!response.ok) {
-        console.warn(`[FrugaSDK] Failed to fetch offer categories: ${response.status}. Returning empty list.`);
-        return [];
-      }
-      const data = await response.json();
-      const categories = data.categories || [];
-      return categories;
-    } catch (error) {
-      console.warn(`[FrugaSDK] Network error fetching offer categories. Returning empty list.`, error);
-      return [];
-    }
+    const response = await this.fetchQuery("/api/offers/categories");
+    assertOk(response, "Failed to fetch offer categories");
+    const data = await response.json();
+    return data.categories || [];
   }
   async getOffers(query) {
-    try {
-      const response = await this.fetchQuery("/api/offers", {
-        pageNumber: query.pageNumber ?? 0,
-        pageSize: query.pageSize ?? 10,
-        type: query.type,
-        query: query.query,
-        featured: query.featured,
-        categories: query.categories
-      });
-      if (!response.ok) {
-        console.warn(`[FrugaSDK] Failed to fetch offers: ${response.status}. Returning empty response.`);
-        return this.getEmptyPaginatedResponse();
-      }
-      const data = await response.json();
-      return {
-        ...data,
-        content: data.content || []
-      };
-    } catch (error) {
-      console.warn(`[FrugaSDK] Network error fetching offers. Returning empty response.`, error);
-      return this.getEmptyPaginatedResponse();
-    }
-  }
-  getEmptyPaginatedResponse() {
+    const response = await this.fetchQuery("/api/offers", {
+      pageNumber: query.pageNumber ?? 0,
+      pageSize: query.pageSize ?? 10,
+      type: query.type,
+      query: query.query,
+      featured: query.featured,
+      categories: query.categories
+    });
+    assertOk(response, "Failed to fetch offers");
+    const data = await response.json();
     return {
-      content: [],
-      totalElements: 0,
-      totalPages: 0,
-      number: 0,
-      size: 0,
-      numberOfElements: 0,
-      numberOfPages: 0
+      ...data,
+      content: data.content || []
     };
   }
 };
@@ -220,23 +217,16 @@ var HttpPayoutService = class {
     this.token = token;
   }
   async listMethods() {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/payout-methods`, {
-        method: "GET",
-        headers: {
-          "Accept": "application/json",
-          "Authorization": `Bearer ${this.token}`
-        }
-      });
-      if (!response.ok) {
-        throw new Error(`Failed to list payout methods: ${response.status}`);
+    const response = await fetch(`${this.baseUrl}/api/payout-methods`, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "Authorization": `Bearer ${this.token}`
       }
-      const data = await response.json();
-      return data.items || [];
-    } catch (error) {
-      console.error("[FrugaSDK] Error listing payout methods:", error);
-      return [];
-    }
+    });
+    assertOk(response, "Failed to list payout methods");
+    const data = await response.json();
+    return data.items || [];
   }
   async addBankMethod(payload) {
     const response = await fetch(`${this.baseUrl}/api/payout-methods/bank`, {
@@ -248,9 +238,7 @@ var HttpPayoutService = class {
       },
       body: JSON.stringify(payload)
     });
-    if (!response.ok) {
-      throw new Error(`Failed to add bank payout method: ${response.status}`);
-    }
+    assertOk(response, "Failed to add bank payout method");
     return response.json();
   }
   async deleteMethod(id) {
@@ -261,53 +249,124 @@ var HttpPayoutService = class {
         "Authorization": `Bearer ${this.token}`
       }
     });
-    if (!response.ok) {
-      throw new Error(`Failed to delete payout method: ${response.status}`);
+    assertOk(response, "Failed to delete payout method");
+  }
+};
+
+// packages/core/src/infrastructure/adapters/PostMessageTransport.ts
+var WILDCARD_ORIGIN = "*";
+var PostMessageTransport = class {
+  constructor(options) {
+    __publicField(this, "target");
+    __publicField(this, "acceptSource");
+    __publicField(this, "listenOn");
+    __publicField(this, "handlers", /* @__PURE__ */ new Set());
+    __publicField(this, "pinOriginFrom");
+    __publicField(this, "targetOrigin");
+    __publicField(this, "acceptOrigin");
+    __publicField(this, "pinned", null);
+    __publicField(this, "disposed", false);
+    __publicField(this, "onMessage", (event) => {
+      if (this.disposed) return;
+      if (this.acceptSource && event.source !== this.acceptSource) return;
+      if (this.acceptOrigin && event.origin !== this.acceptOrigin) return;
+      if (!isFrugaMessage(event.data)) return;
+      if (!this.admitWhileUnpinned(event.data.type, event.origin)) return;
+      const message = typeof event.data.version === "string" && event.data.version.length > 0 ? event.data : { ...event.data, version: PROTOCOL_VERSION };
+      for (const handler of [...this.handlers]) {
+        handler(message);
+      }
+    });
+    const listenOn = options.listenOn ?? (typeof window !== "undefined" ? window : void 0);
+    if (!listenOn) {
+      throw new Error("PostMessageTransport: no window to listen on; pass options.listenOn");
+    }
+    this.target = options.target;
+    this.targetOrigin = options.targetOrigin;
+    this.acceptSource = options.acceptSource;
+    this.acceptOrigin = options.acceptOrigin;
+    this.pinOriginFrom = options.pinOriginFrom;
+    this.listenOn = listenOn;
+    this.listenOn.addEventListener("message", this.onMessage);
+  }
+  /**
+   * Origin the transport has locked onto, `'*'` when it pinned to the wildcard
+   * after an opaque-origin handshake, or `null` while still unpinned.
+   */
+  get pinnedOrigin() {
+    return this.pinned;
+  }
+  /** Lock both the outbound and inbound origin once the peer origin is known. */
+  pinOrigin(origin) {
+    this.targetOrigin = origin;
+    this.acceptOrigin = origin;
+    this.pinned = origin;
+  }
+  send(message) {
+    if (this.disposed) return;
+    const payload = typeof message.version === "string" && message.version.length > 0 ? message : { ...message, version: PROTOCOL_VERSION };
+    this.target.postMessage(payload, this.targetOrigin);
+  }
+  subscribe(handler) {
+    if (this.disposed) {
+      throw new Error("PostMessageTransport: cannot subscribe after dispose()");
+    }
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.handlers.clear();
+    this.listenOn.removeEventListener("message", this.onMessage);
+  }
+  /**
+   * Gate applied only while `pinOriginFrom` is set and the transport is still
+   * unpinned: nothing but the pinning message type gets through, and the first
+   * one that does completes the handshake for everything after it.
+   */
+  admitWhileUnpinned(type, origin) {
+    if (!this.pinOriginFrom || this.pinned !== null) return true;
+    if (type !== this.pinOriginFrom) return false;
+    if (origin && origin !== "null") {
+      this.pinOrigin(origin);
+      return true;
     }
+    this.pinned = WILDCARD_ORIGIN;
+    return true;
   }
 };
 
-// packages/core/src/presentation/components/index.tsx
-import { jsx } from "react/jsx-runtime";
-var WidgetButton = ({
-  children,
-  variant = "primary",
-  style,
-  ...props
-}) => {
-  const baseStyle = {
-    padding: "10px 20px",
-    borderRadius: "8px",
-    border: "none",
-    cursor: "pointer",
-    fontWeight: 600,
-    transition: "opacity 0.2s",
-    backgroundColor: variant === "primary" ? "#007bff" : "#6c757d",
-    color: "white",
-    ...style
-  };
-  return /* @__PURE__ */ jsx("button", { style: baseStyle, ...props, children });
+// packages/core/src/infrastructure/adapters/createHostTransport.ts
+var createHostTransport = (options) => {
+  const win = options?.listenOn ?? (typeof window !== "undefined" ? window : void 0);
+  if (!win) {
+    throw new Error("createHostTransport: no window available; pass options.listenOn");
+  }
+  const framed = win.parent !== win;
+  return new PostMessageTransport({
+    target: win.parent,
+    targetOrigin: "*",
+    pinOriginFrom: "FRUGA_INIT",
+    listenOn: win,
+    ...framed ? { acceptSource: win.parent } : {}
+  });
 };
-var WidgetHeader = ({ title }) => /* @__PURE__ */ jsx("header", { style: {
-  padding: "16px",
-  borderBottom: "1px solid #eee",
-  display: "flex",
-  alignItems: "center",
-  justifyContent: "space-between"
-}, children: /* @__PURE__ */ jsx("h3", { style: { margin: 0, fontSize: "1.1rem" }, children: title }) });
 
 // packages/core/src/presentation/components/WidgetContainer.tsx
-import { useState, useEffect as useEffect2, useRef as useRef2 } from "react";
+import { useState, useEffect as useEffect3, useRef as useRef3 } from "react";
 
 // packages/core/src/presentation/components/ui/LauncherIcon.tsx
 import { Sparkles, CreditCard, MoveUpRight, Gift } from "lucide-react";
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 function LauncherIcon({ theme }) {
   if (theme.launcherIcon === "none") return null;
-  if (theme.launcherIcon === "sparkles") return /* @__PURE__ */ jsx2(Sparkles, { size: 20 });
-  if (theme.launcherIcon === "credit") return /* @__PURE__ */ jsx2(CreditCard, { size: 20 });
-  if (theme.launcherIcon === "arrow") return /* @__PURE__ */ jsx2(MoveUpRight, { size: 20 });
-  return /* @__PURE__ */ jsx2(Gift, { size: 20 });
+  if (theme.launcherIcon === "sparkles") return /* @__PURE__ */ jsx(Sparkles, { size: 20 });
+  if (theme.launcherIcon === "credit") return /* @__PURE__ */ jsx(CreditCard, { size: 20 });
+  if (theme.launcherIcon === "arrow") return /* @__PURE__ */ jsx(MoveUpRight, { size: 20 });
+  return /* @__PURE__ */ jsx(Gift, { size: 20 });
 }
 
 // packages/core/src/presentation/hooks/useActivityDetector.ts
@@ -367,6 +426,8 @@ var useWidgetStore = create((set) => ({
   pending: 0,
   mode: "light",
   token: null,
+  tokenEpoch: 0,
+  authStatus: "pending",
   partnerPayout: null,
   isAddingPayoutFromAlert: false,
   showPayoutSuccess: false,
@@ -376,8 +437,12 @@ var useWidgetStore = create((set) => ({
   setIdle: (idle) => set({ isIdle: idle }),
   setBalances: (available, pending) => set({ available, pending }),
   setMode: (mode) => set({ mode }),
-  setToken: (token) => set({ token }),
-  setPartnerPayout: (payout) => set({ partnerPayout: payout }),
+  setToken: (token) => set((state) => ({
+    token,
+    tokenEpoch: state.token === token ? state.tokenEpoch : state.tokenEpoch + 1,
+    authStatus: token ? "authenticated" : "pending"
+  })),
+  setPartnerPayout: (payout) => set({ partnerPayout: resolvePayoutMode(payout) }),
   setIsAddingPayoutFromAlert: (val) => set({ isAddingPayoutFromAlert: val }),
   setShowPayoutSuccess: (val) => set({ showPayoutSuccess: val })
 }));
@@ -425,6 +490,42 @@ function useActivityDetector() {
   }, [setFocused, setIdle]);
 }
 
+// packages/core/src/presentation/hooks/useMessageTransport.ts
+import { useContext, useEffect as useEffect2, useRef as useRef2 } from "react";
+
+// packages/core/src/presentation/context/MessageTransportContext.tsx
+import { createContext } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var MessageTransportContext = createContext(null);
+var MessageTransportProvider = ({
+  transport,
+  children
+}) => {
+  return /* @__PURE__ */ jsx2(MessageTransportContext.Provider, { value: transport, children });
+};
+
+// packages/core/src/presentation/hooks/useMessageTransport.ts
+var useMessageTransport = () => {
+  const transport = useContext(MessageTransportContext);
+  if (!transport) {
+    throw new Error(
+      "useMessageTransport: no transport in context. Wrap the widget tree in <MessageTransportProvider transport={...}>."
+    );
+  }
+  return transport;
+};
+var useFrugaMessage = (type, handler) => {
+  const transport = useMessageTransport();
+  const handlerRef = useRef2(handler);
+  handlerRef.current = handler;
+  useEffect2(() => {
+    return transport.subscribe((message) => {
+      if (message.type !== type) return;
+      handlerRef.current(message);
+    });
+  }, [transport, type]);
+};
+
 // packages/core/src/presentation/components/WidgetContainer.tsx
 import { X } from "lucide-react";
 import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
@@ -439,35 +540,45 @@ var WidgetContainer = ({
   const theme = themeProp || DEFAULT_THEME;
   const [hostHeight, setHostHeight] = useState(initialHostHeight);
   const [isMobile, setIsMobile] = useState(initialIsMobile);
-  const effectiveTheme = theme.allowUserThemeControl ? { ...theme, mode: storeMode } : { ...theme, mode: theme.mode || "light" };
+  const [hostThemeMode, setHostThemeMode] = useState(void 0);
+  const effectiveTheme = theme.allowUserThemeControl ? { ...theme, mode: storeMode } : { ...theme, mode: hostThemeMode ?? theme.mode ?? "light" };
   const resolved = getResolvedTheme(effectiveTheme);
-  const containerRef = useRef2(null);
-  const buttonRef = useRef2(null);
-  useEffect2(() => {
-    const handler = (event) => {
-      if (event.data?.type === "FRUGA_HOST_RESIZE") {
-        setHostHeight(event.data.hostHeight);
-        setIsMobile(event.data.isHostMobile);
-      }
-      if (event.data?.type === "FRUGA_TOKEN_UPDATE") {
-        const { setToken } = useWidgetStore.getState();
-        setToken(event.data.token);
-      }
-      if (event.data?.type === "FRUGA_GET_BALANCE") {
-        const { available, pending } = useWidgetStore.getState();
-        console.log("FRUGA_GET_BALANCE", available, pending);
-        window.parent.postMessage({
-          type: "FRUGA_BALANCE_RESPONSE",
-          requestId: event.data.requestId,
-          available,
-          pending
-        }, "*");
-      }
-    };
-    window.addEventListener("message", handler);
-    return () => window.removeEventListener("message", handler);
-  }, []);
-  useEffect2(() => {
+  const containerRef = useRef3(null);
+  const buttonRef = useRef3(null);
+  const transport = useMessageTransport();
+  useFrugaMessage("FRUGA_HOST_RESIZE", (message) => {
+    setHostHeight(message.hostHeight);
+    setIsMobile(message.isHostMobile);
+  });
+  useFrugaMessage("FRUGA_TOKEN_UPDATE", (message) => {
+    useWidgetStore.getState().setToken(message.token);
+  });
+  useFrugaMessage("FRUGA_GET_BALANCE", (message) => {
+    const { available, pending } = useWidgetStore.getState();
+    transport.send({
+      type: "FRUGA_BALANCE_RESPONSE",
+      version: PROTOCOL_VERSION,
+      requestId: message.requestId,
+      available,
+      pending
+    });
+  });
+  useFrugaMessage("FRUGA_INIT", (message) => {
+    setHostHeight(message.host.height);
+    setIsMobile(message.host.isMobile);
+    if (message.token) {
+      useWidgetStore.getState().setToken(message.token);
+    }
+    if (message.overrides?.panelOpen) {
+      useWidgetStore.getState().setOpen(true);
+    }
+    const overrideThemeMode = message.overrides?.theme;
+    if (overrideThemeMode) {
+      setHostThemeMode(overrideThemeMode);
+      useWidgetStore.getState().setMode(overrideThemeMode);
+    }
+  });
+  useEffect3(() => {
     if (!containerRef.current) return;
     const sendResize = () => {
       if (!containerRef.current) return;
@@ -480,18 +591,19 @@ var WidgetContainer = ({
         expectedWidth = window.innerWidth;
         expectedHeight = hostHeight;
       }
-      window.parent.postMessage({
+      transport.send({
         type: "FRUGA_RESIZE",
+        version: PROTOCOL_VERSION,
         height: expectedHeight,
         width: expectedWidth,
         isFullscreen: isMobile && isOpen
-      }, "*");
+      });
     };
     const observer = new ResizeObserver(() => sendResize());
     observer.observe(containerRef.current);
     sendResize();
     return () => observer.disconnect();
-  }, [isOpen, hostHeight, isMobile]);
+  }, [isOpen, hostHeight, isMobile, transport]);
   return /* @__PURE__ */ jsxs(
     "div",
     {
@@ -590,10 +702,10 @@ var useWidget = () => {
 };
 
 // packages/core/src/presentation/hooks/useDebounce.ts
-import { useEffect as useEffect3, useState as useState2 } from "react";
+import { useEffect as useEffect4, useState as useState2 } from "react";
 var useDebounce = (value, delay) => {
   const [debouncedValue, setDebouncedValue] = useState2(value);
-  useEffect3(() => {
+  useEffect4(() => {
     const handleTimeout = setTimeout(() => {
       setDebouncedValue(value);
     }, delay);
@@ -605,10 +717,8 @@ var useDebounce = (value, delay) => {
 };
 
 // packages/core/src/infrastructure/storage/StorageService.ts
-var STORAGE_KEYS = {
-  BOOTSTRAP_DATA: "fruga_bootstrap",
-  BOOTSTRAP_CONFIG: "fruga_active_config"
-};
+var LEGACY_BOOTSTRAP_STORAGE_KEY = "fruga_bootstrap";
+var storageKey = (partnerKey, name) => `fruga:${partnerKey}:${name}`;
 var StorageService = class {
   static set(key, value) {
     if (typeof window === "undefined") return;
@@ -630,20 +740,22 @@ var StorageService = class {
   }
   static remove(key) {
     if (typeof window === "undefined") return;
-    window.localStorage.removeItem(key);
-  }
-  static clear() {
-    if (typeof window === "undefined") return;
-    window.localStorage.clear();
+    try {
+      window.localStorage.removeItem(key);
+    } catch (error) {
+      console.warn(`[FrugaStorage] Failed to remove key "${key}":`, error);
+    }
   }
 };
 
 // packages/core/src/infrastructure/config.ts
-var DEFAULT_API_URL = typeof process !== "undefined" && process.env.VITE_FRUGA_API_URL || "https://api-dev.fruga.co.uk";
+var DEFAULT_API_URL = "https://api.fruga.co.uk";
 var getBaseUrl = (override) => {
   if (override) return override;
-  return DEFAULT_API_URL;
+  return "" ? "" : DEFAULT_API_URL;
 };
+var isTestMode = () => false;
+var SDK_VERSION = "1.3.0" ? "1.3.0" : "0.0.0-dev";
 
 // packages/core/src/infrastructure/helpers/date.ts
 var formatDate = (dateStr) => {
@@ -656,7 +768,7 @@ var formatDate = (dateStr) => {
     const month = (date.getMonth() + 1).toString().padStart(2, "0");
     const year = date.getFullYear();
     return `${day}-${month}-${year}`;
-  } catch (e) {
+  } catch {
     return dateStr;
   }
 };
@@ -702,23 +814,38 @@ export {
   DEFAULT_API_URL,
   DEFAULT_THEME,
   DEFAULT_THEME as DefaultTheme,
+  HOST_MOBILE_BREAKPOINT,
   HttpActivityService,
+  HttpError,
   HttpOffersService,
   HttpPayoutService,
   HttpWalletService,
-  STORAGE_KEYS,
+  LEGACY_BOOTSTRAP_STORAGE_KEY,
+  MessageTransportContext,
+  MessageTransportProvider,
+  PROTOCOL_VERSION,
+  PostMessageTransport,
+  SDK_VERSION,
   StorageService,
-  WidgetButton,
+  UnauthorizedError,
   WidgetContainer,
-  WidgetHeader,
   WidgetProvider,
+  createHostTransport,
   formatDate,
   getBaseUrl,
   getDaysRemaining,
   getResolvedTheme,
+  isFrugaMessage,
+  isFrugaMessageType,
+  isTestMode,
   isWithinDays,
+  protocolMajor,
+  resolvePayoutMode,
+  storageKey,
   truncateText,
   useDebounce,
+  useFrugaMessage,
+  useMessageTransport,
   useWidget,
   useWidgetStore
 };