@okeyamy/lua 5.0.4

package/build/es5/__tests__/ai-personalize.test.js

@@ -0,0 +1,811 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+/**
+ * Tests for AI Personalization Engine
+ * Tests config validation, API communication, response validation, and caching
+ */
+
+// Mock localStorage
+var localStorageMock = function () {
+  var store = {};
+  return {
+    getItem: jest.fn(function (key) {
+      return store[key] || null;
+    }),
+    setItem: jest.fn(function (key, val) {
+      store[key] = String(val);
+    }),
+    removeItem: jest.fn(function (key) {
+      delete store[key];
+    }),
+    clear: jest.fn(function () {
+      store = {};
+    }),
+    get length() {
+      return Object.keys(store).length;
+    },
+    key: jest.fn(function (i) {
+      return Object.keys(store)[i] || null;
+    })
+  };
+}();
+Object.defineProperty(global, 'localStorage', {
+  value: localStorageMock
+});
+
+// Mock crypto
+Object.defineProperty(global, 'crypto', {
+  value: {
+    getRandomValues: function getRandomValues(buf) {
+      for (var i = 0; i < buf.length; i++) buf[i] = Math.floor(Math.random() * 256);
+      return buf;
+    }
+  }
+});
+
+// Mock fetch
+global.fetch = jest.fn();
+global.AbortController = /*#__PURE__*/function () {
+  function _class() {
+    (0, _classCallCheck2.default)(this, _class);
+    this.signal = {};
+  }
+  return (0, _createClass2.default)(_class, [{
+    key: "abort",
+    value: function abort() {}
+  }]);
+}();
+
+// Load modules in order (dependencies first)
+require('../storage/weighted-history');
+require('../prompts/personalization-prompts');
+require('../ai-personalize');
+var LuaAIPersonalize = global.LuaAIPersonalize;
+var LuaPrompts = global.LuaPrompts;
+var LuaWeightedHistory = global.LuaWeightedHistory;
+var mockTemplates = {
+  'gaming': {
+    headline: 'Level Up Your Setup',
+    subheadline: 'Pro gear for serious gamers.',
+    ctaLabel: 'Explore Gaming',
+    ctaLink: '/gaming',
+    image: 'gaming.jpg'
+  },
+  'professional': {
+    headline: 'Work Smarter',
+    subheadline: 'Premium productivity tools.',
+    ctaLabel: 'View Collection',
+    ctaLink: '/professional',
+    image: 'pro.jpg'
+  },
+  'default': {
+    headline: 'Welcome',
+    subheadline: 'Discover products.',
+    ctaLabel: 'Shop Now',
+    ctaLink: '/shop',
+    image: 'default.jpg'
+  }
+};
+var mockContext = {
+  utm: {
+    utm_source: 'reddit',
+    utm_campaign: 'gaming_console'
+  },
+  referrer: {
+    source: 'reddit',
+    category: 'social',
+    url: 'https://reddit.com'
+  },
+  userAgent: {
+    isMobile: false,
+    isTablet: false,
+    isDesktop: true,
+    raw: ''
+  },
+  timestamp: Date.now(),
+  hasUTM: true,
+  primaryIntent: 'gaming'
+};
+beforeEach(function () {
+  localStorageMock.clear();
+  jest.clearAllMocks();
+  global.fetch.mockReset();
+});
+describe('LuaAIPersonalize', function () {
+  it('should be registered on global', function () {
+    expect(LuaAIPersonalize).toBeDefined();
+    expect((0, _typeof2.default)(LuaAIPersonalize.decide)).toBe('function');
+    expect((0, _typeof2.default)(LuaAIPersonalize.normalizeConfig)).toBe('function');
+  });
+  describe('normalizeConfig', function () {
+    it('should reject null config', function () {
+      var result = LuaAIPersonalize.normalizeConfig(null);
+      expect(result.valid).toBe(false);
+    });
+    it('should reject config without apiKey or apiUrl', function () {
+      var result = LuaAIPersonalize.normalizeConfig({});
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('apiKey');
+    });
+    it('should accept config with apiKey', function () {
+      var result = LuaAIPersonalize.normalizeConfig({
+        apiKey: 'sk-test123'
+      });
+      expect(result.valid).toBe(true);
+      expect(result.useDirectApi).toBe(true);
+      expect(result.apiKey).toBe('sk-test123');
+    });
+    it('should accept config with apiUrl', function () {
+      var result = LuaAIPersonalize.normalizeConfig({
+        apiUrl: 'https://proxy.example.com/api'
+      });
+      expect(result.valid).toBe(true);
+      expect(result.useDirectApi).toBe(false);
+      expect(result.apiUrl).toBe('https://proxy.example.com/api');
+    });
+    it('should apply defaults for missing fields', function () {
+      var result = LuaAIPersonalize.normalizeConfig({
+        apiKey: 'sk-test'
+      });
+      expect(result.model).toBe('gpt-4o-mini');
+      expect(result.mode).toBe('select');
+      expect(result.timeout).toBe(5000);
+      expect(result.maxRetries).toBe(1);
+      expect(result.fallbackToStandard).toBe(true);
+      expect(result.cacheDecisions).toBe(true);
+      expect(result.historyEnabled).toBe(true);
+      expect(result.historyDecayRate).toBe(0.9);
+    });
+    it('should use custom values when provided', function () {
+      var result = LuaAIPersonalize.normalizeConfig({
+        apiKey: 'sk-test',
+        model: 'gpt-4o',
+        mode: 'generate',
+        timeout: 10000,
+        temperature: 0.5,
+        maxTokens: 1000
+      });
+      expect(result.model).toBe('gpt-4o');
+      expect(result.mode).toBe('generate');
+      expect(result.timeout).toBe(10000);
+      expect(result.temperature).toBe(0.5);
+      expect(result.maxTokens).toBe(1000);
+    });
+    it('should prefer apiUrl over direct when both provided', function () {
+      var result = LuaAIPersonalize.normalizeConfig({
+        apiKey: 'sk-test',
+        apiUrl: 'https://proxy.com/api'
+      });
+      expect(result.useDirectApi).toBe(false);
+      expect(result.apiUrl).toBe('https://proxy.com/api');
+    });
+  });
+  describe('validateSelectResponse', function () {
+    it('should accept valid selection response', function () {
+      var result = LuaAIPersonalize.validateSelectResponse({
+        selectedVariant: 'gaming',
+        confidence: 0.9,
+        reasoning: 'test'
+      }, mockTemplates);
+      expect(result.valid).toBe(true);
+    });
+    it('should reject missing selectedVariant', function () {
+      var result = LuaAIPersonalize.validateSelectResponse({
+        confidence: 0.9
+      }, mockTemplates);
+      expect(result.valid).toBe(false);
+    });
+    it('should reject non-existent variant', function () {
+      var result = LuaAIPersonalize.validateSelectResponse({
+        selectedVariant: 'nonexistent'
+      }, mockTemplates);
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('nonexistent');
+    });
+    it('should reject null response', function () {
+      var result = LuaAIPersonalize.validateSelectResponse(null, mockTemplates);
+      expect(result.valid).toBe(false);
+    });
+  });
+  describe('validateGenerateResponse', function () {
+    it('should accept valid generation response', function () {
+      var result = LuaAIPersonalize.validateGenerateResponse({
+        headline: 'Test Headline',
+        subheadline: 'Test subheadline here',
+        ctaLabel: 'Click Me'
+      });
+      expect(result.valid).toBe(true);
+    });
+    it('should reject missing headline', function () {
+      var result = LuaAIPersonalize.validateGenerateResponse({
+        subheadline: 'Test',
+        ctaLabel: 'Click'
+      });
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('headline');
+    });
+    it('should reject missing subheadline', function () {
+      var result = LuaAIPersonalize.validateGenerateResponse({
+        headline: 'Test',
+        ctaLabel: 'Click'
+      });
+      expect(result.valid).toBe(false);
+    });
+    it('should reject missing ctaLabel', function () {
+      var result = LuaAIPersonalize.validateGenerateResponse({
+        headline: 'Test',
+        subheadline: 'Sub'
+      });
+      expect(result.valid).toBe(false);
+    });
+  });
+  describe('decide (select mode)', function () {
+    it('should call OpenAI and return a valid decision', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var decision;
+      return _regenerator.default.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: JSON.stringify({
+                        selectedVariant: 'gaming',
+                        confidence: 0.92,
+                        reasoning: 'User came from Reddit with gaming console campaign'
+                      })
+                    }
+                  }]
+                });
+              }
+            });
+            _context.next = 1;
+            return LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-test',
+                mode: 'select',
+                cacheDecisions: false,
+                historyEnabled: false
+              }
+            });
+          case 1:
+            decision = _context.sent;
+            expect(decision.intent).toBe('gaming');
+            expect(decision.source).toBe('ai');
+            expect(decision.template).toBe(mockTemplates['gaming']);
+            expect(decision.aiResponse.confidence).toBe(0.92);
+            expect(decision.aiResponse.model).toBe('gpt-4o-mini');
+            expect(decision.aiResponse.mode).toBe('select');
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('should include Authorization header for direct API', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      return _regenerator.default.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: JSON.stringify({
+                        selectedVariant: 'gaming',
+                        confidence: 0.8,
+                        reasoning: 'test'
+                      })
+                    }
+                  }]
+                });
+              }
+            });
+            _context2.next = 1;
+            return LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-mykey123',
+                mode: 'select',
+                cacheDecisions: false,
+                historyEnabled: false
+              }
+            });
+          case 1:
+            expect(global.fetch).toHaveBeenCalledWith('https://api.openai.com/v1/chat/completions', expect.objectContaining({
+              method: 'POST',
+              headers: expect.objectContaining({
+                'Authorization': 'Bearer sk-mykey123'
+              })
+            }));
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+    it('should use proxy URL when apiUrl is provided', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      return _regenerator.default.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: JSON.stringify({
+                        selectedVariant: 'gaming',
+                        confidence: 0.8,
+                        reasoning: 'test'
+                      })
+                    }
+                  }]
+                });
+              }
+            });
+            _context3.next = 1;
+            return LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiUrl: 'https://myproxy.com/openai',
+                mode: 'select',
+                cacheDecisions: false,
+                historyEnabled: false
+              }
+            });
+          case 1:
+            expect(global.fetch).toHaveBeenCalledWith('https://myproxy.com/openai', expect.any(Object));
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+  });
+  describe('decide (generate mode)', function () {
+    it('should call OpenAI and return generated content', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var decision;
+      return _regenerator.default.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: JSON.stringify({
+                        headline: 'Game On, Gear Up',
+                        subheadline: 'The ultimate gaming setup awaits you.',
+                        ctaLabel: 'Level Up',
+                        confidence: 0.88,
+                        reasoning: 'Gamer from Reddit'
+                      })
+                    }
+                  }]
+                });
+              }
+            });
+            _context4.next = 1;
+            return LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-test',
+                mode: 'generate',
+                cacheDecisions: false,
+                historyEnabled: false
+              }
+            });
+          case 1:
+            decision = _context4.sent;
+            expect(decision.intent).toBe('ai-generated');
+            expect(decision.source).toBe('ai');
+            expect(decision.template.headline).toBe('Game On, Gear Up');
+            expect(decision.template.subheadline).toBe('The ultimate gaming setup awaits you.');
+            expect(decision.template.ctaLabel).toBe('Level Up');
+            expect(decision.aiResponse.mode).toBe('generate');
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+  });
+  describe('error handling', function () {
+    it('should reject with error for invalid config', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      return _regenerator.default.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            _context5.next = 1;
+            return expect(LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {}
+            })).rejects.toThrow('apiKey');
+          case 1:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+    it('should reject on API error', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      return _regenerator.default.wrap(function (_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            global.fetch.mockResolvedValueOnce({
+              ok: false,
+              status: 401,
+              text: function text() {
+                return Promise.resolve('Unauthorized');
+              }
+            });
+            _context6.next = 1;
+            return expect(LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-bad',
+                cacheDecisions: false,
+                historyEnabled: false,
+                maxRetries: 0
+              }
+            })).rejects.toThrow('401');
+          case 1:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    })));
+    it('should reject on invalid JSON response', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
+      return _regenerator.default.wrap(function (_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: 'this is not json'
+                    }
+                  }]
+                });
+              }
+            });
+            _context7.next = 1;
+            return expect(LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-test',
+                cacheDecisions: false,
+                historyEnabled: false,
+                maxRetries: 0
+              }
+            })).rejects.toThrow();
+          case 1:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    })));
+    it('should reject on invalid selection (nonexistent variant)', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+      return _regenerator.default.wrap(function (_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: JSON.stringify({
+                        selectedVariant: 'fake',
+                        confidence: 0.5,
+                        reasoning: 'oops'
+                      })
+                    }
+                  }]
+                });
+              }
+            });
+            _context8.next = 1;
+            return expect(LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-test',
+                cacheDecisions: false,
+                historyEnabled: false,
+                maxRetries: 0
+              }
+            })).rejects.toThrow('does not exist');
+          case 1:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    })));
+  });
+  describe('caching', function () {
+    it('should cache a decision and return it on subsequent calls', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
+      var first, second;
+      return _regenerator.default.wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: JSON.stringify({
+                        selectedVariant: 'gaming',
+                        confidence: 0.9,
+                        reasoning: 'test'
+                      })
+                    }
+                  }]
+                });
+              }
+            });
+
+            // First call - hits API
+            _context9.next = 1;
+            return LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-test',
+                cacheDecisions: true,
+                historyEnabled: false
+              }
+            });
+          case 1:
+            first = _context9.sent;
+            expect(first.source).toBe('ai');
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+
+            // Second call - should use cache
+            _context9.next = 2;
+            return LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-test',
+                cacheDecisions: true,
+                historyEnabled: false
+              }
+            });
+          case 2:
+            second = _context9.sent;
+            expect(second.source).toBe('ai-cached');
+            expect(global.fetch).toHaveBeenCalledTimes(1); // No new fetch call
+          case 3:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    })));
+    it('clearCache should remove all cached decisions', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee0() {
+      var result;
+      return _regenerator.default.wrap(function (_context0) {
+        while (1) switch (_context0.prev = _context0.next) {
+          case 0:
+            // Store something in cache
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: JSON.stringify({
+                        selectedVariant: 'gaming',
+                        confidence: 0.9,
+                        reasoning: 'test'
+                      })
+                    }
+                  }]
+                });
+              }
+            });
+            _context0.next = 1;
+            return LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-test',
+                cacheDecisions: true,
+                historyEnabled: false
+              }
+            });
+          case 1:
+            LuaAIPersonalize.clearCache();
+
+            // Next call should hit API again
+            global.fetch.mockResolvedValueOnce({
+              ok: true,
+              json: function json() {
+                return Promise.resolve({
+                  choices: [{
+                    message: {
+                      content: JSON.stringify({
+                        selectedVariant: 'professional',
+                        confidence: 0.8,
+                        reasoning: 'cleared'
+                      })
+                    }
+                  }]
+                });
+              }
+            });
+            _context0.next = 2;
+            return LuaAIPersonalize.decide(mockContext, {
+              templates: mockTemplates,
+              aiConfig: {
+                apiKey: 'sk-test',
+                cacheDecisions: true,
+                historyEnabled: false
+              }
+            });
+          case 2:
+            result = _context0.sent;
+            expect(result.source).toBe('ai');
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+          case 3:
+          case "end":
+            return _context0.stop();
+        }
+      }, _callee0);
+    })));
+  });
+  describe('isReady', function () {
+    it('should return ready for valid config with modules loaded', function () {
+      var result = LuaAIPersonalize.isReady({
+        apiKey: 'sk-test'
+      });
+      expect(result.ready).toBe(true);
+    });
+    it('should return not ready for invalid config', function () {
+      var result = LuaAIPersonalize.isReady({});
+      expect(result.ready).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+});
+describe('LuaPrompts', function () {
+  it('should be registered on global', function () {
+    expect(LuaPrompts).toBeDefined();
+    expect((0, _typeof2.default)(LuaPrompts.buildSelectPrompt)).toBe('function');
+    expect((0, _typeof2.default)(LuaPrompts.buildGeneratePrompt)).toBe('function');
+    expect((0, _typeof2.default)(LuaPrompts.buildMessages)).toBe('function');
+  });
+  describe('buildMessages', function () {
+    it('should build select mode messages', function () {
+      var messages = LuaPrompts.buildMessages('select', {
+        context: mockContext,
+        weightedHistory: 'No history',
+        variants: mockTemplates
+      });
+      expect(messages.length).toBe(2);
+      expect(messages[0].role).toBe('system');
+      expect(messages[1].role).toBe('user');
+      expect(messages[0].content).toContain('personalization');
+      expect(messages[1].content).toContain('reddit');
+      expect(messages[1].content).toContain('gaming');
+      expect(messages[1].content).toContain('AVAILABLE VARIANTS');
+    });
+    it('should build generate mode messages', function () {
+      var messages = LuaPrompts.buildMessages('generate', {
+        context: mockContext,
+        weightedHistory: 'No history',
+        brandContext: {
+          brandVoice: 'bold and energetic',
+          targetAudience: 'gamers'
+        }
+      });
+      expect(messages.length).toBe(2);
+      expect(messages[0].content).toContain('copywriter');
+      expect(messages[1].content).toContain('bold and energetic');
+      expect(messages[1].content).toContain('gamers');
+    });
+    it('should use custom system prompt when provided', function () {
+      var messages = LuaPrompts.buildMessages('select', {
+        context: mockContext,
+        variants: mockTemplates
+      }, {
+        system: 'You are a custom AI.'
+      });
+      expect(messages[0].content).toBe('You are a custom AI.');
+    });
+  });
+  describe('buildSelectPrompt', function () {
+    it('should include all UTM parameters', function () {
+      var prompt = LuaPrompts.buildSelectPrompt({
+        context: {
+          utm: {
+            utm_source: 'google',
+            utm_medium: 'cpc',
+            utm_campaign: 'sale'
+          },
+          referrer: {
+            source: 'google',
+            category: 'search'
+          },
+          userAgent: {
+            isMobile: true,
+            isTablet: false,
+            isDesktop: false
+          },
+          hasUTM: true,
+          primaryIntent: 'price-focused'
+        },
+        weightedHistory: 'New visitor',
+        variants: mockTemplates
+      });
+      expect(prompt).toContain('google');
+      expect(prompt).toContain('cpc');
+      expect(prompt).toContain('sale');
+      expect(prompt).toContain('mobile');
+      expect(prompt).toContain('price-focused');
+    });
+    it('should list all variant keys', function () {
+      var prompt = LuaPrompts.buildSelectPrompt({
+        context: mockContext,
+        variants: mockTemplates
+      });
+      expect(prompt).toContain('"gaming"');
+      expect(prompt).toContain('"professional"');
+      expect(prompt).toContain('"default"');
+    });
+    it('should include preference scores when provided', function () {
+      var prompt = LuaPrompts.buildSelectPrompt({
+        context: mockContext,
+        variants: mockTemplates,
+        preferences: {
+          gaming: 1.5,
+          professional: 0.7
+        }
+      });
+      expect(prompt).toContain('PREFERENCE SCORES');
+      expect(prompt).toContain('gaming');
+      expect(prompt).toContain('1.500');
+    });
+  });
+  describe('buildGeneratePrompt', function () {
+    it('should include brand context fields', function () {
+      var prompt = LuaPrompts.buildGeneratePrompt({
+        context: mockContext,
+        brandContext: {
+          brandVoice: 'friendly and modern',
+          targetAudience: 'young professionals',
+          productType: 'tech accessories',
+          industry: 'e-commerce',
+          customField: 'custom value'
+        }
+      });
+      expect(prompt).toContain('friendly and modern');
+      expect(prompt).toContain('young professionals');
+      expect(prompt).toContain('tech accessories');
+      expect(prompt).toContain('e-commerce');
+      expect(prompt).toContain('custom value');
+    });
+    it('should include reference template when provided', function () {
+      var prompt = LuaPrompts.buildGeneratePrompt({
+        context: mockContext,
+        fallbackTemplate: {
+          headline: 'Default Headline',
+          subheadline: 'Default sub',
+          ctaLabel: 'Default CTA'
+        }
+      });
+      expect(prompt).toContain('Default Headline');
+      expect(prompt).toContain('REFERENCE TEMPLATE');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["localStorageMock","store","getItem","jest","fn","key","setItem","val","String","removeItem","clear","length","Object","keys","i","defineProperty","global","value","getRandomValues","buf","Math","floor","random","fetch","AbortController","_class","_classCallCheck2","default","signal","_createClass2","abort","require","LuaAIPersonalize","LuaPrompts","LuaWeightedHistory","mockTemplates","headline","subheadline","ctaLabel","ctaLink","image","mockContext","utm","utm_source","utm_campaign","referrer","source","category","url","userAgent","isMobile","isTablet","isDesktop","raw","timestamp","Date","now","hasUTM","primaryIntent","beforeEach","clearAllMocks","mockReset","describe","it","expect","toBeDefined","_typeof2","decide","toBe","normalizeConfig","result","valid","error","toContain","apiKey","useDirectApi","apiUrl","model","mode","timeout","maxRetries","fallbackToStandard","cacheDecisions","historyEnabled","historyDecayRate","temperature","maxTokens","validateSelectResponse","selectedVariant","confidence","reasoning","validateGenerateResponse","_asyncToGenerator2","_regenerator","mark","_callee","decision","wrap","_context","prev","next","mockResolvedValueOnce","ok","json","Promise","resolve","choices","message","content","JSON","stringify","templates","aiConfig","sent","intent","template","aiResponse","stop","_callee2","_context2","toHaveBeenCalledWith","objectContaining","method","headers","_callee3","_context3","any","_callee4","_context4","_callee5","_context5","rejects","toThrow","_callee6","_context6","status","text","_callee7","_context7","_callee8","_context8","_callee9","first","second","_context9","toHaveBeenCalledTimes","_callee0","_context0","clearCache","isReady","ready","buildSelectPrompt","buildGeneratePrompt","buildMessages","messages","context","weightedHistory","variants","role","brandContext","brandVoice","targetAudience","system","prompt","utm_medium","preferences","gaming","professional","productType","industry","customField","fallbackTemplate"],"sources":["../../../src/__tests__/ai-personalize.test.js"],"sourcesContent":["\n/**\n * Tests for AI Personalization Engine\n * Tests config validation, API communication, response validation, and caching\n */\n\n// Mock localStorage\nconst localStorageMock = (function () {\n    let store = {}\n    return {\n        getItem: jest.fn(function (key) { return store[key] || null }),\n        setItem: jest.fn(function (key, val) { store[key] = String(val) }),\n        removeItem: jest.fn(function (key) { delete store[key] }),\n        clear: jest.fn(function () { store = {} }),\n        get length() { return Object.keys(store).length },\n        key: jest.fn(function (i) { return Object.keys(store)[i] || null })\n    }\n})()\n\nObject.defineProperty(global, 'localStorage', { value: localStorageMock })\n\n// Mock crypto\nObject.defineProperty(global, 'crypto', {\n    value: {\n        getRandomValues: function (buf) {\n            for (let i = 0; i < buf.length; i++) buf[i] = Math.floor(Math.random() * 256)\n            return buf\n        }\n    }\n})\n\n// Mock fetch\nglobal.fetch = jest.fn()\nglobal.AbortController = class {\n    constructor() { this.signal = {} }\n    abort() {}\n}\n\n// Load modules in order (dependencies first)\nrequire('../storage/weighted-history')\nrequire('../prompts/personalization-prompts')\nrequire('../ai-personalize')\n\nconst LuaAIPersonalize = global.LuaAIPersonalize\nconst LuaPrompts = global.LuaPrompts\nconst LuaWeightedHistory = global.LuaWeightedHistory\n\nconst mockTemplates = {\n    'gaming': {\n        headline: 'Level Up Your Setup',\n        subheadline: 'Pro gear for serious gamers.',\n        ctaLabel: 'Explore Gaming',\n        ctaLink: '/gaming',\n        image: 'gaming.jpg'\n    },\n    'professional': {\n        headline: 'Work Smarter',\n        subheadline: 'Premium productivity tools.',\n        ctaLabel: 'View Collection',\n        ctaLink: '/professional',\n        image: 'pro.jpg'\n    },\n    'default': {\n        headline: 'Welcome',\n        subheadline: 'Discover products.',\n        ctaLabel: 'Shop Now',\n        ctaLink: '/shop',\n        image: 'default.jpg'\n    }\n}\n\nconst mockContext = {\n    utm: { utm_source: 'reddit', utm_campaign: 'gaming_console' },\n    referrer: { source: 'reddit', category: 'social', url: 'https://reddit.com' },\n    userAgent: { isMobile: false, isTablet: false, isDesktop: true, raw: '' },\n    timestamp: Date.now(),\n    hasUTM: true,\n    primaryIntent: 'gaming'\n}\n\nbeforeEach(() => {\n    localStorageMock.clear()\n    jest.clearAllMocks()\n    global.fetch.mockReset()\n})\n\ndescribe('LuaAIPersonalize', () => {\n    it('should be registered on global', () => {\n        expect(LuaAIPersonalize).toBeDefined()\n        expect(typeof LuaAIPersonalize.decide).toBe('function')\n        expect(typeof LuaAIPersonalize.normalizeConfig).toBe('function')\n    })\n\n    describe('normalizeConfig', () => {\n        it('should reject null config', () => {\n            const result = LuaAIPersonalize.normalizeConfig(null)\n            expect(result.valid).toBe(false)\n        })\n\n        it('should reject config without apiKey or apiUrl', () => {\n            const result = LuaAIPersonalize.normalizeConfig({})\n            expect(result.valid).toBe(false)\n            expect(result.error).toContain('apiKey')\n        })\n\n        it('should accept config with apiKey', () => {\n            const result = LuaAIPersonalize.normalizeConfig({ apiKey: 'sk-test123' })\n            expect(result.valid).toBe(true)\n            expect(result.useDirectApi).toBe(true)\n            expect(result.apiKey).toBe('sk-test123')\n        })\n\n        it('should accept config with apiUrl', () => {\n            const result = LuaAIPersonalize.normalizeConfig({ apiUrl: 'https://proxy.example.com/api' })\n            expect(result.valid).toBe(true)\n            expect(result.useDirectApi).toBe(false)\n            expect(result.apiUrl).toBe('https://proxy.example.com/api')\n        })\n\n        it('should apply defaults for missing fields', () => {\n            const result = LuaAIPersonalize.normalizeConfig({ apiKey: 'sk-test' })\n            expect(result.model).toBe('gpt-4o-mini')\n            expect(result.mode).toBe('select')\n            expect(result.timeout).toBe(5000)\n            expect(result.maxRetries).toBe(1)\n            expect(result.fallbackToStandard).toBe(true)\n            expect(result.cacheDecisions).toBe(true)\n            expect(result.historyEnabled).toBe(true)\n            expect(result.historyDecayRate).toBe(0.9)\n        })\n\n        it('should use custom values when provided', () => {\n            const result = LuaAIPersonalize.normalizeConfig({\n                apiKey: 'sk-test',\n                model: 'gpt-4o',\n                mode: 'generate',\n                timeout: 10000,\n                temperature: 0.5,\n                maxTokens: 1000\n            })\n            expect(result.model).toBe('gpt-4o')\n            expect(result.mode).toBe('generate')\n            expect(result.timeout).toBe(10000)\n            expect(result.temperature).toBe(0.5)\n            expect(result.maxTokens).toBe(1000)\n        })\n\n        it('should prefer apiUrl over direct when both provided', () => {\n            const result = LuaAIPersonalize.normalizeConfig({\n                apiKey: 'sk-test',\n                apiUrl: 'https://proxy.com/api'\n            })\n            expect(result.useDirectApi).toBe(false)\n            expect(result.apiUrl).toBe('https://proxy.com/api')\n        })\n    })\n\n    describe('validateSelectResponse', () => {\n        it('should accept valid selection response', () => {\n            const result = LuaAIPersonalize.validateSelectResponse(\n                { selectedVariant: 'gaming', confidence: 0.9, reasoning: 'test' },\n                mockTemplates\n            )\n            expect(result.valid).toBe(true)\n        })\n\n        it('should reject missing selectedVariant', () => {\n            const result = LuaAIPersonalize.validateSelectResponse(\n                { confidence: 0.9 },\n                mockTemplates\n            )\n            expect(result.valid).toBe(false)\n        })\n\n        it('should reject non-existent variant', () => {\n            const result = LuaAIPersonalize.validateSelectResponse(\n                { selectedVariant: 'nonexistent' },\n                mockTemplates\n            )\n            expect(result.valid).toBe(false)\n            expect(result.error).toContain('nonexistent')\n        })\n\n        it('should reject null response', () => {\n            const result = LuaAIPersonalize.validateSelectResponse(null, mockTemplates)\n            expect(result.valid).toBe(false)\n        })\n    })\n\n    describe('validateGenerateResponse', () => {\n        it('should accept valid generation response', () => {\n            const result = LuaAIPersonalize.validateGenerateResponse({\n                headline: 'Test Headline',\n                subheadline: 'Test subheadline here',\n                ctaLabel: 'Click Me'\n            })\n            expect(result.valid).toBe(true)\n        })\n\n        it('should reject missing headline', () => {\n            const result = LuaAIPersonalize.validateGenerateResponse({\n                subheadline: 'Test',\n                ctaLabel: 'Click'\n            })\n            expect(result.valid).toBe(false)\n            expect(result.error).toContain('headline')\n        })\n\n        it('should reject missing subheadline', () => {\n            const result = LuaAIPersonalize.validateGenerateResponse({\n                headline: 'Test',\n                ctaLabel: 'Click'\n            })\n            expect(result.valid).toBe(false)\n        })\n\n        it('should reject missing ctaLabel', () => {\n            const result = LuaAIPersonalize.validateGenerateResponse({\n                headline: 'Test',\n                subheadline: 'Sub'\n            })\n            expect(result.valid).toBe(false)\n        })\n    })\n\n    describe('decide (select mode)', () => {\n        it('should call OpenAI and return a valid decision', async () => {\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: {\n                            content: JSON.stringify({\n                                selectedVariant: 'gaming',\n                                confidence: 0.92,\n                                reasoning: 'User came from Reddit with gaming console campaign'\n                            })\n                        }\n                    }]\n                })\n            })\n\n            const decision = await LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-test', mode: 'select', cacheDecisions: false, historyEnabled: false }\n            })\n\n            expect(decision.intent).toBe('gaming')\n            expect(decision.source).toBe('ai')\n            expect(decision.template).toBe(mockTemplates['gaming'])\n            expect(decision.aiResponse.confidence).toBe(0.92)\n            expect(decision.aiResponse.model).toBe('gpt-4o-mini')\n            expect(decision.aiResponse.mode).toBe('select')\n        })\n\n        it('should include Authorization header for direct API', async () => {\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: { content: JSON.stringify({ selectedVariant: 'gaming', confidence: 0.8, reasoning: 'test' }) }\n                    }]\n                })\n            })\n\n            await LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-mykey123', mode: 'select', cacheDecisions: false, historyEnabled: false }\n            })\n\n            expect(global.fetch).toHaveBeenCalledWith(\n                'https://api.openai.com/v1/chat/completions',\n                expect.objectContaining({\n                    method: 'POST',\n                    headers: expect.objectContaining({\n                        'Authorization': 'Bearer sk-mykey123'\n                    })\n                })\n            )\n        })\n\n        it('should use proxy URL when apiUrl is provided', async () => {\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: { content: JSON.stringify({ selectedVariant: 'gaming', confidence: 0.8, reasoning: 'test' }) }\n                    }]\n                })\n            })\n\n            await LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiUrl: 'https://myproxy.com/openai', mode: 'select', cacheDecisions: false, historyEnabled: false }\n            })\n\n            expect(global.fetch).toHaveBeenCalledWith(\n                'https://myproxy.com/openai',\n                expect.any(Object)\n            )\n        })\n    })\n\n    describe('decide (generate mode)', () => {\n        it('should call OpenAI and return generated content', async () => {\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: {\n                            content: JSON.stringify({\n                                headline: 'Game On, Gear Up',\n                                subheadline: 'The ultimate gaming setup awaits you.',\n                                ctaLabel: 'Level Up',\n                                confidence: 0.88,\n                                reasoning: 'Gamer from Reddit'\n                            })\n                        }\n                    }]\n                })\n            })\n\n            const decision = await LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: {\n                    apiKey: 'sk-test',\n                    mode: 'generate',\n                    cacheDecisions: false,\n                    historyEnabled: false\n                }\n            })\n\n            expect(decision.intent).toBe('ai-generated')\n            expect(decision.source).toBe('ai')\n            expect(decision.template.headline).toBe('Game On, Gear Up')\n            expect(decision.template.subheadline).toBe('The ultimate gaming setup awaits you.')\n            expect(decision.template.ctaLabel).toBe('Level Up')\n            expect(decision.aiResponse.mode).toBe('generate')\n        })\n    })\n\n    describe('error handling', () => {\n        it('should reject with error for invalid config', async () => {\n            await expect(LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: {}\n            })).rejects.toThrow('apiKey')\n        })\n\n        it('should reject on API error', async () => {\n            global.fetch.mockResolvedValueOnce({\n                ok: false,\n                status: 401,\n                text: () => Promise.resolve('Unauthorized')\n            })\n\n            await expect(LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-bad', cacheDecisions: false, historyEnabled: false, maxRetries: 0 }\n            })).rejects.toThrow('401')\n        })\n\n        it('should reject on invalid JSON response', async () => {\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: { content: 'this is not json' }\n                    }]\n                })\n            })\n\n            await expect(LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-test', cacheDecisions: false, historyEnabled: false, maxRetries: 0 }\n            })).rejects.toThrow()\n        })\n\n        it('should reject on invalid selection (nonexistent variant)', async () => {\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: { content: JSON.stringify({ selectedVariant: 'fake', confidence: 0.5, reasoning: 'oops' }) }\n                    }]\n                })\n            })\n\n            await expect(LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-test', cacheDecisions: false, historyEnabled: false, maxRetries: 0 }\n            })).rejects.toThrow('does not exist')\n        })\n    })\n\n    describe('caching', () => {\n        it('should cache a decision and return it on subsequent calls', async () => {\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: { content: JSON.stringify({ selectedVariant: 'gaming', confidence: 0.9, reasoning: 'test' }) }\n                    }]\n                })\n            })\n\n            // First call - hits API\n            const first = await LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-test', cacheDecisions: true, historyEnabled: false }\n            })\n            expect(first.source).toBe('ai')\n            expect(global.fetch).toHaveBeenCalledTimes(1)\n\n            // Second call - should use cache\n            const second = await LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-test', cacheDecisions: true, historyEnabled: false }\n            })\n            expect(second.source).toBe('ai-cached')\n            expect(global.fetch).toHaveBeenCalledTimes(1) // No new fetch call\n        })\n\n        it('clearCache should remove all cached decisions', async () => {\n            // Store something in cache\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: { content: JSON.stringify({ selectedVariant: 'gaming', confidence: 0.9, reasoning: 'test' }) }\n                    }]\n                })\n            })\n\n            await LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-test', cacheDecisions: true, historyEnabled: false }\n            })\n\n            LuaAIPersonalize.clearCache()\n\n            // Next call should hit API again\n            global.fetch.mockResolvedValueOnce({\n                ok: true,\n                json: () => Promise.resolve({\n                    choices: [{\n                        message: { content: JSON.stringify({ selectedVariant: 'professional', confidence: 0.8, reasoning: 'cleared' }) }\n                    }]\n                })\n            })\n\n            const result = await LuaAIPersonalize.decide(mockContext, {\n                templates: mockTemplates,\n                aiConfig: { apiKey: 'sk-test', cacheDecisions: true, historyEnabled: false }\n            })\n            expect(result.source).toBe('ai')\n            expect(global.fetch).toHaveBeenCalledTimes(2)\n        })\n    })\n\n    describe('isReady', () => {\n        it('should return ready for valid config with modules loaded', () => {\n            const result = LuaAIPersonalize.isReady({ apiKey: 'sk-test' })\n            expect(result.ready).toBe(true)\n        })\n\n        it('should return not ready for invalid config', () => {\n            const result = LuaAIPersonalize.isReady({})\n            expect(result.ready).toBe(false)\n            expect(result.error).toBeDefined()\n        })\n    })\n})\n\ndescribe('LuaPrompts', () => {\n    it('should be registered on global', () => {\n        expect(LuaPrompts).toBeDefined()\n        expect(typeof LuaPrompts.buildSelectPrompt).toBe('function')\n        expect(typeof LuaPrompts.buildGeneratePrompt).toBe('function')\n        expect(typeof LuaPrompts.buildMessages).toBe('function')\n    })\n\n    describe('buildMessages', () => {\n        it('should build select mode messages', () => {\n            const messages = LuaPrompts.buildMessages('select', {\n                context: mockContext,\n                weightedHistory: 'No history',\n                variants: mockTemplates\n            })\n\n            expect(messages.length).toBe(2)\n            expect(messages[0].role).toBe('system')\n            expect(messages[1].role).toBe('user')\n            expect(messages[0].content).toContain('personalization')\n            expect(messages[1].content).toContain('reddit')\n            expect(messages[1].content).toContain('gaming')\n            expect(messages[1].content).toContain('AVAILABLE VARIANTS')\n        })\n\n        it('should build generate mode messages', () => {\n            const messages = LuaPrompts.buildMessages('generate', {\n                context: mockContext,\n                weightedHistory: 'No history',\n                brandContext: {\n                    brandVoice: 'bold and energetic',\n                    targetAudience: 'gamers'\n                }\n            })\n\n            expect(messages.length).toBe(2)\n            expect(messages[0].content).toContain('copywriter')\n            expect(messages[1].content).toContain('bold and energetic')\n            expect(messages[1].content).toContain('gamers')\n        })\n\n        it('should use custom system prompt when provided', () => {\n            const messages = LuaPrompts.buildMessages('select', {\n                context: mockContext,\n                variants: mockTemplates\n            }, {\n                system: 'You are a custom AI.'\n            })\n\n            expect(messages[0].content).toBe('You are a custom AI.')\n        })\n    })\n\n    describe('buildSelectPrompt', () => {\n        it('should include all UTM parameters', () => {\n            const prompt = LuaPrompts.buildSelectPrompt({\n                context: {\n                    utm: { utm_source: 'google', utm_medium: 'cpc', utm_campaign: 'sale' },\n                    referrer: { source: 'google', category: 'search' },\n                    userAgent: { isMobile: true, isTablet: false, isDesktop: false },\n                    hasUTM: true,\n                    primaryIntent: 'price-focused'\n                },\n                weightedHistory: 'New visitor',\n                variants: mockTemplates\n            })\n\n            expect(prompt).toContain('google')\n            expect(prompt).toContain('cpc')\n            expect(prompt).toContain('sale')\n            expect(prompt).toContain('mobile')\n            expect(prompt).toContain('price-focused')\n        })\n\n        it('should list all variant keys', () => {\n            const prompt = LuaPrompts.buildSelectPrompt({\n                context: mockContext,\n                variants: mockTemplates\n            })\n\n            expect(prompt).toContain('\"gaming\"')\n            expect(prompt).toContain('\"professional\"')\n            expect(prompt).toContain('\"default\"')\n        })\n\n        it('should include preference scores when provided', () => {\n            const prompt = LuaPrompts.buildSelectPrompt({\n                context: mockContext,\n                variants: mockTemplates,\n                preferences: { gaming: 1.5, professional: 0.7 }\n            })\n\n            expect(prompt).toContain('PREFERENCE SCORES')\n            expect(prompt).toContain('gaming')\n            expect(prompt).toContain('1.500')\n        })\n    })\n\n    describe('buildGeneratePrompt', () => {\n        it('should include brand context fields', () => {\n            const prompt = LuaPrompts.buildGeneratePrompt({\n                context: mockContext,\n                brandContext: {\n                    brandVoice: 'friendly and modern',\n                    targetAudience: 'young professionals',\n                    productType: 'tech accessories',\n                    industry: 'e-commerce',\n                    customField: 'custom value'\n                }\n            })\n\n            expect(prompt).toContain('friendly and modern')\n            expect(prompt).toContain('young professionals')\n            expect(prompt).toContain('tech accessories')\n            expect(prompt).toContain('e-commerce')\n            expect(prompt).toContain('custom value')\n        })\n\n        it('should include reference template when provided', () => {\n            const prompt = LuaPrompts.buildGeneratePrompt({\n                context: mockContext,\n                fallbackTemplate: {\n                    headline: 'Default Headline',\n                    subheadline: 'Default sub',\n                    ctaLabel: 'Default CTA'\n                }\n            })\n\n            expect(prompt).toContain('Default Headline')\n            expect(prompt).toContain('REFERENCE TEMPLATE')\n        })\n    })\n})\n"],"mappings":"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","ignoreList":[]}