@fruga/sdk 1.0.4 → 1.3.0

package/dist/index.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,6 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // packages/core/src/index.ts
 var src_exports = {};
@@ -33,23 +35,38 @@ __export(src_exports, {
   DEFAULT_API_URL: () => DEFAULT_API_URL,
   DEFAULT_THEME: () => DEFAULT_THEME,
   DefaultTheme: () => DEFAULT_THEME,
+  HOST_MOBILE_BREAKPOINT: () => HOST_MOBILE_BREAKPOINT,
   HttpActivityService: () => HttpActivityService,
+  HttpError: () => HttpError,
   HttpOffersService: () => HttpOffersService,
   HttpPayoutService: () => HttpPayoutService,
   HttpWalletService: () => HttpWalletService,
-  STORAGE_KEYS: () => STORAGE_KEYS,
+  LEGACY_BOOTSTRAP_STORAGE_KEY: () => LEGACY_BOOTSTRAP_STORAGE_KEY,
+  MessageTransportContext: () => MessageTransportContext,
+  MessageTransportProvider: () => MessageTransportProvider,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  PostMessageTransport: () => PostMessageTransport,
+  SDK_VERSION: () => SDK_VERSION,
   StorageService: () => StorageService,
-  WidgetButton: () => WidgetButton,
+  UnauthorizedError: () => UnauthorizedError,
   WidgetContainer: () => WidgetContainer,
-  WidgetHeader: () => WidgetHeader,
   WidgetProvider: () => WidgetProvider,
+  createHostTransport: () => createHostTransport,
   formatDate: () => formatDate,
   getBaseUrl: () => getBaseUrl,
   getDaysRemaining: () => getDaysRemaining,
   getResolvedTheme: () => getResolvedTheme,
+  isFrugaMessage: () => isFrugaMessage,
+  isFrugaMessageType: () => isFrugaMessageType,
+  isTestMode: () => isTestMode,
   isWithinDays: () => isWithinDays,
+  protocolMajor: () => protocolMajor,
+  resolvePayoutMode: () => resolvePayoutMode,
+  storageKey: () => storageKey,
   truncateText: () => truncateText,
   useDebounce: () => useDebounce,
+  useFrugaMessage: () => useFrugaMessage,
+  useMessageTransport: () => useMessageTransport,
   useWidget: () => useWidget,
   useWidgetStore: () => useWidgetStore
 });
@@ -108,50 +125,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";
   }
 };
 
@@ -181,6 +199,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 {
@@ -188,27 +241,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 || []
     };
   }
 };
@@ -219,53 +257,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 || []
     };
   }
 };
@@ -277,23 +287,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`, {
@@ -305,9 +308,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) {
@@ -318,53 +319,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
-var import_jsx_runtime = require("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__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsx)("header", { style: {
-  padding: "16px",
-  borderBottom: "1px solid #eee",
-  display: "flex",
-  alignItems: "center",
-  justifyContent: "space-between"
-}, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h3", { style: { margin: 0, fontSize: "1.1rem" }, children: title }) });
 
 // packages/core/src/presentation/components/WidgetContainer.tsx
-var import_react3 = require("react");
+var import_react5 = require("react");
 
 // packages/core/src/presentation/components/ui/LauncherIcon.tsx
 var import_lucide_react = require("lucide-react");
-var import_jsx_runtime2 = require("react/jsx-runtime");
+var import_jsx_runtime = require("react/jsx-runtime");
 function LauncherIcon({ theme }) {
   if (theme.launcherIcon === "none") return null;
-  if (theme.launcherIcon === "sparkles") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Sparkles, { size: 20 });
-  if (theme.launcherIcon === "credit") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.CreditCard, { size: 20 });
-  if (theme.launcherIcon === "arrow") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.MoveUpRight, { size: 20 });
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Gift, { size: 20 });
+  if (theme.launcherIcon === "sparkles") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_lucide_react.Sparkles, { size: 20 });
+  if (theme.launcherIcon === "credit") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_lucide_react.CreditCard, { size: 20 });
+  if (theme.launcherIcon === "arrow") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_lucide_react.MoveUpRight, { size: 20 });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_lucide_react.Gift, { size: 20 });
 }
 
 // packages/core/src/presentation/hooks/useActivityDetector.ts
@@ -424,6 +496,8 @@ var useWidgetStore = create((set) => ({
   pending: 0,
   mode: "light",
   token: null,
+  tokenEpoch: 0,
+  authStatus: "pending",
   partnerPayout: null,
   isAddingPayoutFromAlert: false,
   showPayoutSuccess: false,
@@ -433,8 +507,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 })
 }));
@@ -482,6 +560,42 @@ function useActivityDetector() {
   }, [setFocused, setIdle]);
 }
 
+// packages/core/src/presentation/hooks/useMessageTransport.ts
+var import_react4 = require("react");
+
+// packages/core/src/presentation/context/MessageTransportContext.tsx
+var import_react3 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var MessageTransportContext = (0, import_react3.createContext)(null);
+var MessageTransportProvider = ({
+  transport,
+  children
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MessageTransportContext.Provider, { value: transport, children });
+};
+
+// packages/core/src/presentation/hooks/useMessageTransport.ts
+var useMessageTransport = () => {
+  const transport = (0, import_react4.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 = (0, import_react4.useRef)(handler);
+  handlerRef.current = handler;
+  (0, import_react4.useEffect)(() => {
+    return transport.subscribe((message) => {
+      if (message.type !== type) return;
+      handlerRef.current(message);
+    });
+  }, [transport, type]);
+};
+
 // packages/core/src/presentation/components/WidgetContainer.tsx
 var import_lucide_react2 = require("lucide-react");
 var import_jsx_runtime3 = require("react/jsx-runtime");
@@ -494,37 +608,47 @@ var WidgetContainer = ({
   useActivityDetector();
   const { isOpen, toggle, mode: storeMode } = useWidgetStore();
   const theme = themeProp || DEFAULT_THEME;
-  const [hostHeight, setHostHeight] = (0, import_react3.useState)(initialHostHeight);
-  const [isMobile, setIsMobile] = (0, import_react3.useState)(initialIsMobile);
-  const effectiveTheme = theme.allowUserThemeControl ? { ...theme, mode: storeMode } : { ...theme, mode: theme.mode || "light" };
+  const [hostHeight, setHostHeight] = (0, import_react5.useState)(initialHostHeight);
+  const [isMobile, setIsMobile] = (0, import_react5.useState)(initialIsMobile);
+  const [hostThemeMode, setHostThemeMode] = (0, import_react5.useState)(void 0);
+  const effectiveTheme = theme.allowUserThemeControl ? { ...theme, mode: storeMode } : { ...theme, mode: hostThemeMode ?? theme.mode ?? "light" };
   const resolved = getResolvedTheme(effectiveTheme);
-  const containerRef = (0, import_react3.useRef)(null);
-  const buttonRef = (0, import_react3.useRef)(null);
-  (0, import_react3.useEffect)(() => {
-    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);
-  }, []);
-  (0, import_react3.useEffect)(() => {
+  const containerRef = (0, import_react5.useRef)(null);
+  const buttonRef = (0, import_react5.useRef)(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);
+    }
+  });
+  (0, import_react5.useEffect)(() => {
     if (!containerRef.current) return;
     const sendResize = () => {
       if (!containerRef.current) return;
@@ -537,18 +661,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__ */ (0, import_jsx_runtime3.jsxs)(
     "div",
     {
@@ -647,10 +772,10 @@ var useWidget = () => {
 };
 
 // packages/core/src/presentation/hooks/useDebounce.ts
-var import_react4 = require("react");
+var import_react6 = require("react");
 var useDebounce = (value, delay) => {
-  const [debouncedValue, setDebouncedValue] = (0, import_react4.useState)(value);
-  (0, import_react4.useEffect)(() => {
+  const [debouncedValue, setDebouncedValue] = (0, import_react6.useState)(value);
+  (0, import_react6.useEffect)(() => {
     const handleTimeout = setTimeout(() => {
       setDebouncedValue(value);
     }, delay);
@@ -662,10 +787,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;
@@ -687,20 +810,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) => {
@@ -713,7 +838,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;
   }
 };
@@ -760,23 +885,38 @@ var truncateText = (str, maxLength = 40) => {
   DEFAULT_API_URL,
   DEFAULT_THEME,
   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
 });