@adobe/spacecat-shared-tokowaka-client 1.1.0 → 1.2.0

package/test/index.test.js

@@ -50,7 +50,12 @@ describe('TokowakaClient', () => {
     };
 
     client = new TokowakaClient(
-      { bucketName: 'test-bucket', s3Client, env },
+      {
+        bucketName: 'test-bucket',
+        previewBucketName: 'test-preview-bucket',
+        s3Client,
+        env,
+      },
       log,
     );
 
@@ -59,8 +64,8 @@ describe('TokowakaClient', () => {
       getBaseURL: () => 'https://example.com',
       getConfig: () => ({
         getTokowakaConfig: () => ({
-          apiKey: 'test-api-key-123',
           forwardedHost: 'example.com',
+          apiKey: 'test-api-key',
         }),
       }),
     };
@@ -108,6 +113,7 @@ describe('TokowakaClient', () => {
     it('should create an instance with valid config', () => {
       expect(client).to.be.instanceOf(TokowakaClient);
       expect(client.deployBucketName).to.equal('test-bucket');
+      expect(client.previewBucketName).to.equal('test-preview-bucket');
       expect(client.s3Client).to.equal(s3Client);
     });
 
@@ -120,12 +126,24 @@ describe('TokowakaClient', () => {
       expect(() => new TokowakaClient({ bucketName: 'test-bucket' }, log))
         .to.throw('S3 client is required');
     });
+
+    it('should use deployBucketName for preview if previewBucketName not provided', () => {
+      const clientWithoutPreview = new TokowakaClient(
+        { bucketName: 'test-bucket', s3Client },
+        log,
+      );
+      // previewBucketName is undefined if not explicitly provided
+      expect(clientWithoutPreview.previewBucketName).to.be.undefined;
+    });
   });
 
   describe('createFrom', () => {
     it('should create client from context', () => {
       const context = {
-        env: { TOKOWAKA_SITE_CONFIG_BUCKET: 'test-bucket' },
+        env: {
+          TOKOWAKA_SITE_CONFIG_BUCKET: 'test-bucket',
+          TOKOWAKA_PREVIEW_BUCKET: 'test-preview-bucket',
+        },
         s3: { s3Client },
         log,
       };
@@ -134,6 +152,7 @@ describe('TokowakaClient', () => {
 
       expect(createdClient).to.be.instanceOf(TokowakaClient);
       expect(context.tokowakaClient).to.equal(createdClient);
+      expect(createdClient.previewBucketName).to.equal('test-preview-bucket');
     });
 
     it('should reuse existing client from context', () => {
@@ -177,13 +196,8 @@ describe('TokowakaClient', () => {
         }
 
         // eslint-disable-next-line class-methods-use-this
-        suggestionToPatch() {
-          return {};
-        }
-
-        // eslint-disable-next-line class-methods-use-this
-        validateSuggestionData() {
-          return true;
+        suggestionsToPatches() {
+          return [];
         }
 
         // eslint-disable-next-line class-methods-use-this
@@ -201,21 +215,20 @@ describe('TokowakaClient', () => {
   });
 
   describe('generateConfig', () => {
-    it('should generate config for headings opportunity', () => {
-      const config = client.generateConfig(mockSite, mockOpportunity, mockSuggestions, null);
+    it('should generate config for headings opportunity with single URL', () => {
+      const url = 'https://example.com/page1';
+      const config = client.generateConfig(url, mockOpportunity, mockSuggestions);
 
       expect(config).to.deep.include({
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
+        forceFail: false,
+        prerender: true,
       });
 
-      expect(config.tokowakaOptimizations).to.have.property('/page1');
-      expect(config.tokowakaOptimizations['/page1'].prerender).to.be.true;
-      expect(config.tokowakaOptimizations['/page1'].patches).to.have.length(2);
+      expect(config.patches).to.have.length(2);
 
-      const patch = config.tokowakaOptimizations['/page1'].patches[0];
+      const patch = config.patches[0];
       expect(patch).to.include({
         op: 'replace',
         selector: 'h1',
@@ -270,21 +283,20 @@ describe('TokowakaClient', () => {
         },
       ];
 
-      const config = client.generateConfig(mockSite, mockOpportunity, mockSuggestions, null);
+      const url = 'https://example.com/page1';
+      const config = client.generateConfig(url, mockOpportunity, mockSuggestions);
 
       expect(config).to.deep.include({
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
+        forceFail: false,
+        prerender: true,
       });
 
-      expect(config.tokowakaOptimizations).to.have.property('/page1');
-      expect(config.tokowakaOptimizations['/page1'].prerender).to.be.true;
-      expect(config.tokowakaOptimizations['/page1'].patches).to.have.length(3); // heading + 2 FAQs
+      expect(config.patches).to.have.length(3); // heading + 2 FAQs
 
       // First patch: heading (no suggestionId)
-      const headingPatch = config.tokowakaOptimizations['/page1'].patches[0];
+      const headingPatch = config.patches[0];
       expect(headingPatch).to.include({
         op: 'appendChild',
         selector: 'main',
@@ -296,7 +308,7 @@ describe('TokowakaClient', () => {
       expect(headingPatch.value.tagName).to.equal('h2');
 
       // Second patch: first FAQ
-      const firstFaqPatch = config.tokowakaOptimizations['/page1'].patches[1];
+      const firstFaqPatch = config.patches[1];
       expect(firstFaqPatch).to.include({
         op: 'appendChild',
         selector: 'main',
@@ -304,217 +316,234 @@ describe('TokowakaClient', () => {
         prerenderRequired: true,
       });
       expect(firstFaqPatch.suggestionId).to.equal('sugg-faq-1');
-      expect(firstFaqPatch).to.have.property('lastUpdated');
       expect(firstFaqPatch.value.tagName).to.equal('div');
-
-      // Third patch: second FAQ
-      const secondFaqPatch = config.tokowakaOptimizations['/page1'].patches[2];
-      expect(secondFaqPatch).to.include({
-        op: 'appendChild',
-        selector: 'main',
-        opportunityId: 'opp-faq-123',
-        prerenderRequired: true,
-      });
-      expect(secondFaqPatch.suggestionId).to.equal('sugg-faq-2');
-      expect(secondFaqPatch).to.have.property('lastUpdated');
-      expect(secondFaqPatch.value.tagName).to.equal('div');
     });
 
-    it('should group suggestions by URL path', () => {
+    it('should return null if no eligible suggestions', () => {
       mockSuggestions = [
         {
           getId: () => 'sugg-1',
-          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
           getData: () => ({
             url: 'https://example.com/page1',
-            recommendedAction: 'Page 1 Heading',
-            checkType: 'heading-empty',
-            transformRules: {
-              action: 'replace',
-              selector: 'h1',
-            },
-          }),
-        },
-        {
-          getId: () => 'sugg-2',
-          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
-          getData: () => ({
-            url: 'https://example.com/page2',
-            recommendedAction: 'Page 2 Heading',
-            checkType: 'heading-empty',
-            transformRules: {
-              action: 'replace',
-              selector: 'h1',
-            },
+            // Missing required fields
           }),
         },
       ];
 
-      const config = client.generateConfig(mockSite, mockOpportunity, mockSuggestions, null);
+      const url = 'https://example.com/page1';
+      const config = client.generateConfig(url, mockOpportunity, mockSuggestions);
 
-      expect(Object.keys(config.tokowakaOptimizations)).to.have.length(2);
-      expect(config.tokowakaOptimizations).to.have.property('/page1');
-      expect(config.tokowakaOptimizations).to.have.property('/page2');
+      expect(config).to.be.null;
     });
 
-    it('should use overrideBaseURL from fetchConfig when available', () => {
-      // Set up mockSite with overrideBaseURL
-      mockSite.getConfig = () => ({
-        getTokowakaConfig: () => ({
-          apiKey: 'test-api-key-123',
-          cdnProvider: 'cloudfront',
-        }),
-        getFetchConfig: () => ({
-          overrideBaseURL: 'https://override.example.com',
-        }),
-      });
+    it('should handle unsupported opportunity types', () => {
+      mockOpportunity.getType = () => 'unsupported-type';
 
-      mockSuggestions = [
-        {
-          getId: () => 'sugg-override',
-          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
-          getData: () => ({
-            url: '/relative-path',
-            recommendedAction: 'Heading',
-            checkType: 'heading-empty',
-            transformRules: {
-              action: 'replace',
-              selector: 'h1',
-            },
-          }),
+      expect(() => client.generateConfig('https://example.com/page1', mockOpportunity, mockSuggestions))
+        .to.throw(/No mapper found for opportunity type: unsupported-type/)
+        .with.property('status', 501);
+    });
+  });
+
+  describe('fetchMetaconfig', () => {
+    it('should fetch metaconfig from S3', async () => {
+      const metaconfig = {
+        siteId: 'site-123',
+        prerender: true,
+      };
+
+      s3Client.send.resolves({
+        Body: {
+          transformToString: async () => JSON.stringify(metaconfig),
         },
-      ];
+      });
 
-      const config = client.generateConfig(mockSite, mockOpportunity, mockSuggestions, null);
+      const result = await client.fetchMetaconfig('https://example.com/page1');
+
+      expect(result).to.deep.equal(metaconfig);
+      expect(s3Client.send).to.have.been.calledOnce;
 
-      expect(Object.keys(config.tokowakaOptimizations)).to.have.length(1);
-      expect(config.tokowakaOptimizations).to.have.property('/relative-path');
+      const command = s3Client.send.firstCall.args[0];
+      expect(command.input.Bucket).to.equal('test-bucket');
+      expect(command.input.Key).to.equal('opportunities/example.com/config');
     });
 
-    it('should skip suggestions without URL', () => {
-      mockSuggestions = [
-        {
-          getId: () => 'sugg-1',
-          getData: () => ({
-            selector: 'h1',
-            value: 'Heading without URL',
-          }),
+    it('should fetch metaconfig from preview bucket', async () => {
+      const metaconfig = {
+        siteId: 'site-123',
+        prerender: true,
+      };
+
+      s3Client.send.resolves({
+        Body: {
+          transformToString: async () => JSON.stringify(metaconfig),
         },
-      ];
+      });
 
-      const config = client.generateConfig(mockSite, mockOpportunity, mockSuggestions, null);
+      await client.fetchMetaconfig('https://example.com/page1', true);
 
-      expect(Object.keys(config.tokowakaOptimizations)).to.have.length(0);
-      expect(log.warn).to.have.been.calledWith(sinon.match(/does not have a URL/));
+      const command = s3Client.send.firstCall.args[0];
+      expect(command.input.Bucket).to.equal('test-preview-bucket');
+      expect(command.input.Key).to.equal('preview/opportunities/example.com/config');
     });
 
-    it('should skip suggestions with invalid URL', () => {
-      mockSuggestions = [
-        {
-          getId: () => 'sugg-1',
-          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
-          getData: () => ({
-            url: 'http://invalid domain with spaces.com',
-            checkType: 'heading-empty',
-            recommendedAction: 'Heading',
-            transformRules: {
-              action: 'replace',
-              selector: 'h1',
-            },
-          }),
-        },
-      ];
+    it('should return null if metaconfig does not exist', async () => {
+      const noSuchKeyError = new Error('NoSuchKey');
+      noSuchKeyError.name = 'NoSuchKey';
+      s3Client.send.rejects(noSuchKeyError);
 
-      const config = client.generateConfig(mockSite, mockOpportunity, mockSuggestions, null);
+      const result = await client.fetchMetaconfig('https://example.com/page1');
 
-      expect(Object.keys(config.tokowakaOptimizations)).to.have.length(0);
-      expect(log.warn).to.have.been.calledWith(sinon.match(/Failed to extract pathname from URL/));
+      expect(result).to.be.null;
     });
 
-    it('should skip suggestions with missing required fields', () => {
-      mockSuggestions = [
-        {
-          getId: () => 'sugg-1',
-          getData: () => ({
-            url: 'https://example.com/page1',
-            // Missing required fields
-          }),
-        },
-      ];
+    it('should throw error on S3 fetch failure', async () => {
+      const s3Error = new Error('Access Denied');
+      s3Error.name = 'AccessDenied';
+      s3Client.send.rejects(s3Error);
+
+      try {
+        await client.fetchMetaconfig('https://example.com/page1');
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('S3 fetch failed');
+        expect(error.status).to.equal(500);
+      }
+    });
+
+    it('should throw error if URL is missing', async () => {
+      try {
+        await client.fetchMetaconfig('');
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('URL is required');
+        expect(error.status).to.equal(400);
+      }
+    });
+  });
+
+  describe('uploadMetaconfig', () => {
+    it('should upload metaconfig to S3', async () => {
+      const metaconfig = {
+        siteId: 'site-123',
+        prerender: true,
+      };
 
-      const config = client.generateConfig(mockSite, mockOpportunity, mockSuggestions);
+      const s3Path = await client.uploadMetaconfig('https://example.com/page1', metaconfig);
+
+      expect(s3Path).to.equal('opportunities/example.com/config');
+      expect(s3Client.send).to.have.been.calledOnce;
 
-      expect(Object.keys(config.tokowakaOptimizations)).to.have.length(0);
-      expect(log.warn).to.have.been.calledWith(sinon.match(/cannot be deployed/));
+      const command = s3Client.send.firstCall.args[0];
+      expect(command.input.Bucket).to.equal('test-bucket');
+      expect(command.input.Key).to.equal('opportunities/example.com/config');
+      expect(command.input.ContentType).to.equal('application/json');
+      expect(JSON.parse(command.input.Body)).to.deep.equal(metaconfig);
     });
 
-    it('should handle unsupported opportunity types', () => {
-      mockOpportunity.getType = () => 'unsupported-type';
-      mockSuggestions = [
-        {
-          getId: () => 'sugg-1',
-          getData: () => ({
-            url: 'https://example.com/page1',
-          }),
-        },
-      ];
+    it('should upload metaconfig to preview bucket', async () => {
+      const metaconfig = {
+        siteId: 'site-123',
+        prerender: true,
+      };
 
-      expect(() => client.generateConfig(mockSite, mockOpportunity, mockSuggestions, null))
-        .to.throw(/No mapper found for opportunity type: unsupported-type/)
-        .with.property('status', 501);
+      const s3Path = await client.uploadMetaconfig('https://example.com/page1', metaconfig, true);
+
+      expect(s3Path).to.equal('preview/opportunities/example.com/config');
+
+      const command = s3Client.send.firstCall.args[0];
+      expect(command.input.Bucket).to.equal('test-preview-bucket');
     });
 
-    it('should generate config without allOpportunitySuggestions', () => {
-      const config = client.generateConfig(mockSite, mockOpportunity, mockSuggestions, null);
+    it('should throw error if URL is missing', async () => {
+      try {
+        await client.uploadMetaconfig('', { siteId: 'site-123', prerender: true });
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('URL is required');
+        expect(error.status).to.equal(400);
+      }
+    });
 
-      expect(config).to.deep.include({
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
-        version: '1.0',
-        tokowakaForceFail: false,
-      });
+    it('should throw error if metaconfig is empty', async () => {
+      try {
+        await client.uploadMetaconfig('https://example.com/page1', {});
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Metaconfig object is required');
+        expect(error.status).to.equal(400);
+      }
+    });
+
+    it('should throw error on S3 upload failure', async () => {
+      const s3Error = new Error('Access Denied');
+      s3Client.send.rejects(s3Error);
 
-      expect(config.tokowakaOptimizations).to.have.property('/page1');
+      try {
+        await client.uploadMetaconfig('https://example.com/page1', { siteId: 'site-123', prerender: true });
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('S3 upload failed');
+        expect(error.status).to.equal(500);
+      }
     });
   });
 
   describe('uploadConfig', () => {
     it('should upload config to S3', async () => {
       const config = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {},
+        forceFail: false,
+        prerender: true,
+        patches: [],
       };
 
-      const s3Key = await client.uploadConfig('test-api-key', config);
+      const s3Key = await client.uploadConfig('https://example.com/page1', config);
 
-      expect(s3Key).to.equal('opportunities/test-api-key');
+      expect(s3Key).to.equal('opportunities/example.com/L3BhZ2Ux');
       expect(s3Client.send).to.have.been.calledOnce;
 
       const command = s3Client.send.firstCall.args[0];
       expect(command.input.Bucket).to.equal('test-bucket');
-      expect(command.input.Key).to.equal('opportunities/test-api-key');
+      expect(command.input.Key).to.equal('opportunities/example.com/L3BhZ2Ux');
       expect(command.input.ContentType).to.equal('application/json');
       expect(JSON.parse(command.input.Body)).to.deep.equal(config);
     });
 
-    it('should throw error if apiKey is missing', async () => {
-      const config = { siteId: 'site-123' };
+    it('should upload config to preview bucket', async () => {
+      const config = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        patches: [],
+      };
+
+      const s3Key = await client.uploadConfig('https://example.com/page1', config, true);
+
+      expect(s3Key).to.equal('preview/opportunities/example.com/L3BhZ2Ux');
+
+      const command = s3Client.send.firstCall.args[0];
+      expect(command.input.Bucket).to.equal('test-preview-bucket');
+      expect(command.input.Key).to.equal('preview/opportunities/example.com/L3BhZ2Ux');
+    });
+
+    it('should throw error if URL is missing', async () => {
+      const config = { url: 'https://example.com/page1', patches: [] };
 
       try {
         await client.uploadConfig('', config);
         expect.fail('Should have thrown error');
       } catch (error) {
-        expect(error.message).to.include('Tokowaka API key is required');
+        expect(error.message).to.include('URL is required');
         expect(error.status).to.equal(400);
       }
     });
 
     it('should throw error if config is empty', async () => {
       try {
-        await client.uploadConfig('test-api-key', {});
+        await client.uploadConfig('https://example.com/page1', {});
         expect.fail('Should have thrown error');
       } catch (error) {
         expect(error.message).to.include('Config object is required');
@@ -524,10 +553,10 @@ describe('TokowakaClient', () => {
 
     it('should handle S3 upload failure', async () => {
       s3Client.send.rejects(new Error('Network error'));
-      const config = { siteId: 'site-123', tokowakaOptimizations: {} };
+      const config = { url: 'https://example.com/page1', patches: [] };
 
       try {
-        await client.uploadConfig('test-api-key', config);
+        await client.uploadConfig('https://example.com/page1', config);
         expect.fail('Should have thrown error');
       } catch (error) {
         expect(error.message).to.include('S3 upload failed');
@@ -539,26 +568,21 @@ describe('TokowakaClient', () => {
   describe('fetchConfig', () => {
     it('should fetch existing config from S3', async () => {
       const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Old Heading',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-1',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Old Heading',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-1',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+        ],
       };
 
       s3Client.send.resolves({
@@ -567,14 +591,36 @@ describe('TokowakaClient', () => {
         },
       });
 
-      const config = await client.fetchConfig('test-api-key');
+      const config = await client.fetchConfig('https://example.com/page1');
 
       expect(config).to.deep.equal(existingConfig);
       expect(s3Client.send).to.have.been.calledOnce;
 
       const command = s3Client.send.firstCall.args[0];
       expect(command.input.Bucket).to.equal('test-bucket');
-      expect(command.input.Key).to.equal('opportunities/test-api-key');
+      expect(command.input.Key).to.equal('opportunities/example.com/L3BhZ2Ux');
+    });
+
+    it('should fetch config from preview bucket', async () => {
+      const existingConfig = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        patches: [],
+      };
+
+      s3Client.send.resolves({
+        Body: {
+          transformToString: async () => JSON.stringify(existingConfig),
+        },
+      });
+
+      await client.fetchConfig('https://example.com/page1', true);
+
+      const command = s3Client.send.firstCall.args[0];
+      expect(command.input.Bucket).to.equal('test-preview-bucket');
+      expect(command.input.Key).to.equal('preview/opportunities/example.com/L3BhZ2Ux');
     });
 
     it('should return null if config does not exist', async () => {
@@ -582,7 +628,7 @@ describe('TokowakaClient', () => {
       noSuchKeyError.name = 'NoSuchKey';
       s3Client.send.rejects(noSuchKeyError);
 
-      const config = await client.fetchConfig('test-api-key');
+      const config = await client.fetchConfig('https://example.com/page1');
 
       expect(config).to.be.null;
     });
@@ -592,17 +638,17 @@ describe('TokowakaClient', () => {
       noSuchKeyError.Code = 'NoSuchKey';
       s3Client.send.rejects(noSuchKeyError);
 
-      const config = await client.fetchConfig('test-api-key');
+      const config = await client.fetchConfig('https://example.com/page1');
 
       expect(config).to.be.null;
     });
 
-    it('should throw error if apiKey is missing', async () => {
+    it('should throw error if URL is missing', async () => {
       try {
         await client.fetchConfig('');
         expect.fail('Should have thrown error');
       } catch (error) {
-        expect(error.message).to.include('Tokowaka API key is required');
+        expect(error.message).to.include('URL is required');
         expect(error.status).to.equal(400);
       }
     });
@@ -611,7 +657,7 @@ describe('TokowakaClient', () => {
       s3Client.send.rejects(new Error('Network error'));
 
       try {
-        await client.fetchConfig('test-api-key');
+        await client.fetchConfig('https://example.com/page1');
         expect.fail('Should have thrown error');
       } catch (error) {
         expect(error.message).to.include('S3 fetch failed');
@@ -626,58 +672,48 @@ describe('TokowakaClient', () => {
 
     beforeEach(() => {
       existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Old Heading',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-1',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-              {
-                op: 'replace',
-                selector: 'h2',
-                value: 'Old Subtitle',
-                opportunityId: 'opp-456',
-                suggestionId: 'sugg-2',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Old Heading',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-1',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+          {
+            op: 'replace',
+            selector: 'h2',
+            value: 'Old Subtitle',
+            opportunityId: 'opp-456',
+            suggestionId: 'sugg-2',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
+          },
+        ],
       };
 
       newConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Updated Heading',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-1',
-                prerenderRequired: true,
-                lastUpdated: 1234567900,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Updated Heading',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-1',
+            prerenderRequired: true,
+            lastUpdated: 1234567900,
           },
-        },
+        ],
       };
     });
 
@@ -690,21 +726,21 @@ describe('TokowakaClient', () => {
     it('should update existing patch with same opportunityId and suggestionId', () => {
       const merged = client.mergeConfigs(existingConfig, newConfig);
 
-      expect(merged.tokowakaOptimizations['/page1'].patches).to.have.length(2);
+      expect(merged.patches).to.have.length(2);
 
       // First patch should be updated
-      const updatedPatch = merged.tokowakaOptimizations['/page1'].patches[0];
+      const updatedPatch = merged.patches[0];
       expect(updatedPatch.value).to.equal('Updated Heading');
       expect(updatedPatch.lastUpdated).to.equal(1234567900);
 
       // Second patch should remain unchanged
-      const unchangedPatch = merged.tokowakaOptimizations['/page1'].patches[1];
+      const unchangedPatch = merged.patches[1];
       expect(unchangedPatch.value).to.equal('Old Subtitle');
       expect(unchangedPatch.opportunityId).to.equal('opp-456');
     });
 
     it('should add new patch if opportunityId and suggestionId do not exist', () => {
-      newConfig.tokowakaOptimizations['/page1'].patches.push({
+      newConfig.patches.push({
         op: 'replace',
         selector: 'h3',
         value: 'New Section Title',
@@ -716,106 +752,59 @@ describe('TokowakaClient', () => {
 
       const merged = client.mergeConfigs(existingConfig, newConfig);
 
-      expect(merged.tokowakaOptimizations['/page1'].patches).to.have.length(3);
+      expect(merged.patches).to.have.length(3);
 
       // New patch should be added at the end
-      const newPatch = merged.tokowakaOptimizations['/page1'].patches[2];
+      const newPatch = merged.patches[2];
       expect(newPatch.value).to.equal('New Section Title');
       expect(newPatch.opportunityId).to.equal('opp-789');
       expect(newPatch.suggestionId).to.equal('sugg-3');
     });
 
-    it('should add new URL path if it does not exist in existing config', () => {
-      newConfig.tokowakaOptimizations['/page2'] = {
-        prerender: true,
-        patches: [
-          {
-            op: 'replace',
-            selector: 'h1',
-            value: 'Page 2 Heading',
-            opportunityId: 'opp-999',
-            suggestionId: 'sugg-4',
-            prerenderRequired: true,
-            lastUpdated: 1234567900,
-          },
-        ],
-      };
-
-      const merged = client.mergeConfigs(existingConfig, newConfig);
-
-      expect(merged.tokowakaOptimizations).to.have.property('/page1');
-      expect(merged.tokowakaOptimizations).to.have.property('/page2');
-      expect(merged.tokowakaOptimizations['/page2'].patches).to.have.length(1);
-      expect(merged.tokowakaOptimizations['/page2'].patches[0].value).to.equal('Page 2 Heading');
-    });
-
-    it('should preserve existing URL paths not present in new config', () => {
-      existingConfig.tokowakaOptimizations['/page3'] = {
-        prerender: false,
-        patches: [
-          {
-            op: 'replace',
-            selector: 'h1',
-            value: 'Page 3 Heading',
-            opportunityId: 'opp-333',
-            suggestionId: 'sugg-5',
-            prerenderRequired: false,
-            lastUpdated: 1234567890,
-          },
-        ],
-      };
-
-      const merged = client.mergeConfigs(existingConfig, newConfig);
-
-      expect(merged.tokowakaOptimizations).to.have.property('/page1');
-      expect(merged.tokowakaOptimizations).to.have.property('/page3');
-      expect(merged.tokowakaOptimizations['/page3'].patches[0].value).to.equal('Page 3 Heading');
-    });
-
     it('should update config metadata from new config', () => {
       newConfig.version = '2.0';
-      newConfig.tokowakaForceFail = true;
+      newConfig.forceFail = true;
 
       const merged = client.mergeConfigs(existingConfig, newConfig);
 
       expect(merged.version).to.equal('2.0');
-      expect(merged.tokowakaForceFail).to.equal(true);
+      expect(merged.forceFail).to.equal(true);
     });
 
     it('should handle empty patches array in existing config', () => {
-      existingConfig.tokowakaOptimizations['/page1'].patches = [];
+      existingConfig.patches = [];
 
       const merged = client.mergeConfigs(existingConfig, newConfig);
 
-      expect(merged.tokowakaOptimizations['/page1'].patches).to.have.length(1);
-      expect(merged.tokowakaOptimizations['/page1'].patches[0].value).to.equal('Updated Heading');
+      expect(merged.patches).to.have.length(1);
+      expect(merged.patches[0].value).to.equal('Updated Heading');
     });
 
     it('should handle empty patches array in new config', () => {
-      newConfig.tokowakaOptimizations['/page1'].patches = [];
+      newConfig.patches = [];
 
       const merged = client.mergeConfigs(existingConfig, newConfig);
 
-      expect(merged.tokowakaOptimizations['/page1'].patches).to.have.length(2);
-      expect(merged.tokowakaOptimizations['/page1'].patches[0].value).to.equal('Old Heading');
+      expect(merged.patches).to.have.length(2);
+      expect(merged.patches[0].value).to.equal('Old Heading');
     });
 
-    it('should handle missing patches property in existing config', () => {
-      delete existingConfig.tokowakaOptimizations['/page1'].patches;
+    it('should handle undefined patches in existing config', () => {
+      existingConfig.patches = undefined;
 
       const merged = client.mergeConfigs(existingConfig, newConfig);
 
-      expect(merged.tokowakaOptimizations['/page1'].patches).to.have.length(1);
-      expect(merged.tokowakaOptimizations['/page1'].patches[0].value).to.equal('Updated Heading');
+      expect(merged.patches).to.have.length(1);
+      expect(merged.patches[0].value).to.equal('Updated Heading');
     });
 
-    it('should handle missing patches property in new config', () => {
-      delete newConfig.tokowakaOptimizations['/page1'].patches;
+    it('should handle undefined patches in new config', () => {
+      newConfig.patches = undefined;
 
       const merged = client.mergeConfigs(existingConfig, newConfig);
 
-      expect(merged.tokowakaOptimizations['/page1'].patches).to.have.length(2);
-      expect(merged.tokowakaOptimizations['/page1'].patches[0].value).to.equal('Old Heading');
+      expect(merged.patches).to.have.length(2);
+      expect(merged.patches[0].value).to.equal('Old Heading');
     });
   });
 
@@ -829,6 +818,10 @@ describe('TokowakaClient', () => {
       });
       // Stub fetchConfig to return null by default (no existing config)
       sinon.stub(client, 'fetchConfig').resolves(null);
+      // Stub fetchMetaconfig to return null by default (will create new)
+      sinon.stub(client, 'fetchMetaconfig').resolves(null);
+      // Stub uploadMetaconfig
+      sinon.stub(client, 'uploadMetaconfig').resolves('opportunities/example.com/config');
     });
 
     it('should deploy suggestions successfully', async () => {
@@ -838,33 +831,98 @@ describe('TokowakaClient', () => {
         mockSuggestions,
       );
 
-      expect(result).to.have.property('s3Path', 'opportunities/test-api-key-123');
-      expect(s3Client.send).to.have.been.calledOnce;
+      expect(result).to.have.property('s3Paths');
+      expect(result.s3Paths).to.be.an('array').with.length(1);
+      expect(result.s3Paths[0]).to.equal('opportunities/example.com/L3BhZ2Ux');
+      expect(result).to.have.property('cdnInvalidations');
+      expect(result.cdnInvalidations).to.be.an('array').with.length(1);
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(s3Client.send).to.have.been.called;
     });
 
-    it('should throw error if site does not have Tokowaka API key', async () => {
-      mockSite.getConfig = () => ({
-        getTokowakaConfig: () => ({}),
+    it('should create metaconfig on first deployment', async () => {
+      await client.deploySuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+      );
+
+      expect(client.fetchMetaconfig).to.have.been.calledOnce;
+      expect(client.uploadMetaconfig).to.have.been.calledOnce;
+
+      const metaconfigArg = client.uploadMetaconfig.firstCall.args[1];
+      expect(metaconfigArg).to.deep.include({
+        siteId: 'site-123',
+        prerender: true,
       });
+    });
 
-      try {
-        await client.deploySuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Tokowaka API key configured');
-        expect(error.status).to.equal(400);
-      }
+    it('should reuse existing metaconfig', async () => {
+      client.fetchMetaconfig.resolves({
+        siteId: 'site-123',
+        prerender: true,
+      });
+
+      await client.deploySuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+      );
+
+      expect(client.fetchMetaconfig).to.have.been.calledOnce;
+      expect(client.uploadMetaconfig).to.not.have.been.called;
+    });
+
+    it('should handle suggestions for multiple URLs', async () => {
+      mockSuggestions = [
+        {
+          getId: () => 'sugg-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page1',
+            recommendedAction: 'Page 1 Heading',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h1',
+            },
+          }),
+        },
+        {
+          getId: () => 'sugg-2',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page2',
+            recommendedAction: 'Page 2 Heading',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h1',
+            },
+          }),
+        },
+      ];
+
+      const result = await client.deploySuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+      );
+
+      expect(result.s3Paths).to.have.length(2);
+      expect(result.cdnInvalidations).to.have.length(2);
+      expect(result.succeededSuggestions).to.have.length(2);
     });
 
     it('should handle suggestions that are not eligible for deployment', async () => {
-      // Create suggestions with different checkTypes
       mockSuggestions = [
         {
           getId: () => 'sugg-1',
           getData: () => ({
             url: 'https://example.com/page1',
             recommendedAction: 'New Heading',
-            checkType: 'heading-missing', // Not eligible (wrong checkType name)
+            checkType: 'heading-missing', // Not eligible
           }),
         },
         {
@@ -893,15 +951,27 @@ describe('TokowakaClient', () => {
       expect(result.failedSuggestions[0].reason).to.include('can be deployed');
     });
 
-    it('should return early when no eligible suggestions', async () => {
-      // All suggestions are ineligible
+    it('should handle multi-URL deploy where one URL has no eligible suggestions', async () => {
       mockSuggestions = [
         {
           getId: () => 'sugg-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
           getData: () => ({
             url: 'https://example.com/page1',
             recommendedAction: 'New Heading',
-            checkType: 'heading-missing', // Wrong checkType name, not eligible
+            checkType: 'heading-empty', // Eligible
+            transformRules: {
+              action: 'replace',
+              selector: 'h1',
+            },
+          }),
+        },
+        {
+          getId: () => 'sugg-2',
+          getData: () => ({
+            url: 'https://example.com/page2',
+            recommendedAction: 'New Heading',
+            checkType: 'heading-missing', // Not eligible
           }),
         },
       ];
@@ -912,20 +982,32 @@ describe('TokowakaClient', () => {
         mockSuggestions,
       );
 
-      expect(result.succeededSuggestions).to.have.length(0);
+      expect(result.succeededSuggestions).to.have.length(1);
       expect(result.failedSuggestions).to.have.length(1);
-      expect(log.warn).to.have.been.calledWith('No eligible suggestions to deploy');
-      expect(s3Client.send).to.not.have.been.called;
-    });
+      expect(result.failedSuggestions[0].suggestion.getId()).to.equal('sugg-2');
+    });
+
+    it('should skip URL when generateConfig returns no patches', async () => {
+      // Stub mapper to return empty patches for the first call, normal for subsequent calls
+      const mapper = client.mapperRegistry.getMapper('headings');
+      const originalSuggestionsToPatches = mapper.suggestionsToPatches.bind(mapper);
+      let callCount = 0;
+      sinon.stub(mapper, 'suggestionsToPatches').callsFake((...args) => {
+        callCount += 1;
+        if (callCount === 1) {
+          // First call (for page1) returns no patches
+          return [];
+        }
+        // Subsequent calls work normally
+        return originalSuggestionsToPatches(...args);
+      });
 
-    it('should return early when suggestions pass eligibility but fail during config generation', async () => {
-      // Suggestions pass canDeploy but have no URL (caught in generateConfig)
       mockSuggestions = [
         {
           getId: () => 'sugg-1',
           getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
           getData: () => ({
-            // Missing URL
+            url: 'https://example.com/page1',
             recommendedAction: 'New Heading',
             checkType: 'heading-empty',
             transformRules: {
@@ -934,6 +1016,42 @@ describe('TokowakaClient', () => {
             },
           }),
         },
+        {
+          getId: () => 'sugg-2',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page2',
+            recommendedAction: 'New Subtitle',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h2',
+            },
+          }),
+        },
+      ];
+
+      const result = await client.deploySuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+      );
+
+      // Both suggestions are in result but sugg-1 skipped deployment due to no patches
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.s3Paths).to.have.length(1); // Only one URL actually deployed
+    });
+
+    it('should return early when no eligible suggestions', async () => {
+      mockSuggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({
+            url: 'https://example.com/page1',
+            recommendedAction: 'New Heading',
+            checkType: 'heading-missing', // Wrong checkType name, not eligible
+          }),
+        },
       ];
 
       const result = await client.deploySuggestions(
@@ -944,6 +1062,7 @@ describe('TokowakaClient', () => {
 
       expect(result.succeededSuggestions).to.have.length(0);
       expect(result.failedSuggestions).to.have.length(1);
+      expect(log.warn).to.have.been.calledWith('No eligible suggestions to deploy');
       expect(s3Client.send).to.not.have.been.called;
     });
 
@@ -955,63 +1074,27 @@ describe('TokowakaClient', () => {
         expect.fail('Should have thrown error');
       } catch (error) {
         expect(error.message).to.include('No mapper found for opportunity type: unsupported-type');
-        expect(error.message).to.include('Supported types:');
         expect(error.status).to.equal(501);
       }
     });
 
-    it('should handle null tokowakaConfig gracefully', async () => {
-      mockSite.getConfig = () => ({
-        getTokowakaConfig: () => null,
-      });
-
-      try {
-        await client.deploySuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Tokowaka API key configured');
-      }
-    });
-
-    it('should use default reason when eligibility has no reason', async () => {
-      // Create a mock mapper that returns eligible=false without reason
-      const mockMapper = {
-        canDeploy: sinon.stub().returns({ eligible: false }), // No reason provided
-      };
-      sinon.stub(client.mapperRegistry, 'getMapper').returns(mockMapper);
-
-      const result = await client.deploySuggestions(
-        mockSite,
-        mockOpportunity,
-        mockSuggestions,
-      );
-
-      expect(result.failedSuggestions).to.have.length(2);
-      expect(result.failedSuggestions[0].reason).to.equal('Suggestion cannot be deployed');
-    });
-
     it('should fetch existing config and merge when deploying', async () => {
       const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h3',
-                value: 'Existing Heading',
-                opportunityId: 'opp-999',
-                suggestionId: 'sugg-999',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h3',
+            value: 'Existing Heading',
+            opportunityId: 'opp-999',
+            suggestionId: 'sugg-999',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+        ],
       };
 
       client.fetchConfig.resolves(existingConfig);
@@ -1022,53 +1105,31 @@ describe('TokowakaClient', () => {
         mockSuggestions,
       );
 
-      expect(client.fetchConfig).to.have.been.calledWith('test-api-key-123');
-      expect(result).to.have.property('s3Path', 'opportunities/test-api-key-123');
+      expect(client.fetchConfig).to.have.been.called;
+      expect(result.s3Paths).to.have.length(1);
 
       // Verify the uploaded config contains both existing and new patches
       const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches).to.have.length(3);
-    });
-
-    it('should use new config when no existing config found', async () => {
-      client.fetchConfig.resolves(null);
-
-      const result = await client.deploySuggestions(
-        mockSite,
-        mockOpportunity,
-        mockSuggestions,
-      );
-
-      expect(client.fetchConfig).to.have.been.calledWith('test-api-key-123');
-      expect(result).to.have.property('s3Path', 'opportunities/test-api-key-123');
-
-      // Verify only new patches are in the config
-      const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches).to.have.length(2);
+      expect(uploadedConfig.patches).to.have.length(3);
     });
 
     it('should update existing patch when deploying same opportunityId and suggestionId', async () => {
       const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Old Heading Value',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-1',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Old Heading Value',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-1',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+        ],
       };
 
       client.fetchConfig.resolves(existingConfig);
@@ -1079,75 +1140,19 @@ describe('TokowakaClient', () => {
         mockSuggestions,
       );
 
-      expect(result).to.have.property('s3Path', 'opportunities/test-api-key-123');
+      expect(result.s3Paths).to.have.length(1);
 
       // Verify the patch was updated, not duplicated
       const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches).to.have.length(2);
+      expect(uploadedConfig.patches).to.have.length(2);
 
       // First patch should be updated with new value
-      const updatedPatch = uploadedConfig.tokowakaOptimizations['/page1'].patches[0];
+      const updatedPatch = uploadedConfig.patches[0];
       expect(updatedPatch.value).to.equal('New Heading');
       expect(updatedPatch.opportunityId).to.equal('opp-123');
       expect(updatedPatch.suggestionId).to.equal('sugg-1');
       expect(updatedPatch.lastUpdated).to.be.greaterThan(1234567890);
     });
-
-    it('should preserve existing URL paths when merging', async () => {
-      const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
-        version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Page 1 Heading',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-1',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
-          },
-          '/other-page': {
-            prerender: false,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Other Page Heading',
-                opportunityId: 'opp-888',
-                suggestionId: 'sugg-888',
-                prerenderRequired: false,
-                lastUpdated: 1234567890,
-              },
-            ],
-          },
-        },
-      };
-
-      client.fetchConfig.resolves(existingConfig);
-
-      const result = await client.deploySuggestions(
-        mockSite,
-        mockOpportunity,
-        mockSuggestions,
-      );
-
-      expect(result).to.have.property('s3Path', 'opportunities/test-api-key-123');
-
-      // Verify existing URL paths are preserved
-      const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations).to.have.property('/page1');
-      expect(uploadedConfig.tokowakaOptimizations).to.have.property('/other-page');
-      expect(uploadedConfig.tokowakaOptimizations['/other-page'].patches[0].value)
-        .to.equal('Other Page Heading');
-    });
   });
 
   describe('rollbackSuggestions', () => {
@@ -1162,44 +1167,39 @@ describe('TokowakaClient', () => {
 
     it('should rollback suggestions successfully', async () => {
       const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Heading 1',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-1',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-              {
-                op: 'replace',
-                selector: 'h2',
-                value: 'Heading 2',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-2',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-              {
-                op: 'replace',
-                selector: 'h3',
-                value: 'Heading 3',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-3',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Heading 1',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-1',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+          {
+            op: 'replace',
+            selector: 'h2',
+            value: 'Heading 2',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-2',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
+          },
+          {
+            op: 'replace',
+            selector: 'h3',
+            value: 'Heading 3',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-3',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
+          },
+        ],
       };
 
       sinon.stub(client, 'fetchConfig').resolves(existingConfig);
@@ -1210,41 +1210,16 @@ describe('TokowakaClient', () => {
         mockSuggestions, // Only sugg-1 and sugg-2
       );
 
-      expect(result).to.have.property('s3Path', 'opportunities/test-api-key-123');
+      expect(result.s3Paths).to.have.length(1);
+      expect(result.s3Paths[0]).to.equal('opportunities/example.com/L3BhZ2Ux');
       expect(result.succeededSuggestions).to.have.length(2);
       expect(result.failedSuggestions).to.have.length(0);
       expect(result.removedPatchesCount).to.equal(2);
 
       // Verify uploaded config has sugg-3 but not sugg-1 and sugg-2
       const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches).to.have.length(1);
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches[0].suggestionId).to.equal('sugg-3');
-    });
-
-    it('should throw error if site does not have Tokowaka API key', async () => {
-      mockSite.getConfig = () => ({
-        getTokowakaConfig: () => ({}),
-      });
-
-      try {
-        await client.rollbackSuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Tokowaka API key configured');
-        expect(error.status).to.equal(400);
-      }
-    });
-
-    it('should throw error if site getConfig returns null', async () => {
-      mockSite.getConfig = () => null;
-
-      try {
-        await client.rollbackSuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Tokowaka API key configured');
-        expect(error.status).to.equal(400);
-      }
+      expect(uploadedConfig.patches).to.have.length(1);
+      expect(uploadedConfig.patches[0].suggestionId).to.equal('sugg-3');
     });
 
     it('should handle no existing config gracefully', async () => {
@@ -1256,19 +1231,20 @@ describe('TokowakaClient', () => {
         mockSuggestions,
       );
 
-      expect(result.succeededSuggestions).to.have.length(0);
-      expect(result.failedSuggestions).to.have.length(2);
-      expect(result.failedSuggestions[0].reason).to.include('No existing configuration found');
+      // Code continues and marks eligible suggestions as succeeded even if no config found
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.s3Paths).to.have.length(0);
       expect(s3Client.send).to.not.have.been.called;
     });
 
-    it('should handle empty existing config optimizations', async () => {
+    it('should handle empty existing config patches', async () => {
       const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {},
+        forceFail: false,
+        prerender: true,
+        patches: [],
       };
 
       sinon.stub(client, 'fetchConfig').resolves(existingConfig);
@@ -1279,34 +1255,30 @@ describe('TokowakaClient', () => {
         mockSuggestions,
       );
 
-      expect(result.succeededSuggestions).to.have.length(0);
-      expect(result.failedSuggestions).to.have.length(2);
-      expect(result.failedSuggestions[0].reason).to.include('No patches found');
+      // Code marks eligible suggestions as succeeded even if no patches to remove
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.s3Paths).to.have.length(0);
       expect(s3Client.send).to.not.have.been.called;
     });
 
     it('should handle suggestions not found in config', async () => {
       const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Heading',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-999', // Different suggestion ID
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Heading',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-999', // Different suggestion ID
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+        ],
       };
 
       sinon.stub(client, 'fetchConfig').resolves(existingConfig);
@@ -1317,15 +1289,15 @@ describe('TokowakaClient', () => {
         mockSuggestions,
       );
 
-      expect(result.succeededSuggestions).to.have.length(0);
-      expect(result.failedSuggestions).to.have.length(2);
-      expect(result.failedSuggestions[0].reason).to.include('No patches found');
+      // Code marks eligible suggestions as succeeded even if patches not found
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.s3Paths).to.have.length(0);
       expect(s3Client.send).to.not.have.been.called;
     });
 
-    it('should return early when all suggestions are ineligible', async () => {
-      // Create suggestions where ALL are ineligible
-      const allIneligibleSuggestions = [
+    it('should return early when all suggestions are ineligible for rollback', async () => {
+      const ineligibleSuggestions = [
         {
           getId: () => 'sugg-1',
           getData: () => ({
@@ -1338,8 +1310,8 @@ describe('TokowakaClient', () => {
           getId: () => 'sugg-2',
           getData: () => ({
             url: 'https://example.com/page1',
-            recommendedAction: 'New Heading',
-            checkType: 'heading-invalid', // Not eligible
+            recommendedAction: 'New Subtitle',
+            checkType: 'heading-wrong', // Not eligible
           }),
         },
       ];
@@ -1347,25 +1319,60 @@ describe('TokowakaClient', () => {
       const result = await client.rollbackSuggestions(
         mockSite,
         mockOpportunity,
-        allIneligibleSuggestions,
+        ineligibleSuggestions,
       );
 
       expect(result.succeededSuggestions).to.have.length(0);
       expect(result.failedSuggestions).to.have.length(2);
-      expect(result.failedSuggestions[0].reason).to.include('can be deployed');
-      expect(result.failedSuggestions[1].reason).to.include('can be deployed');
       expect(s3Client.send).to.not.have.been.called;
     });
 
-    it('should handle ineligible suggestions during rollback', async () => {
-      // Create suggestions where one is ineligible
-      const mixedSuggestions = [
+    it('should delete config file when all patches are rolled back', async () => {
+      // Code uploads empty config instead of deleting
+      const existingConfig = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Heading 1',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-1',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
+          },
+        ],
+      };
+
+      sinon.stub(client, 'fetchConfig').resolves(existingConfig);
+
+      const result = await client.rollbackSuggestions(
+        mockSite,
+        mockOpportunity,
+        [mockSuggestions[0]], // Only roll back sugg-1 (all patches for this URL)
+      );
+
+      expect(result.succeededSuggestions).to.have.length(1);
+      expect(result.removedPatchesCount).to.equal(1);
+
+      // Code uploads empty patches array instead of deleting
+      expect(s3Client.send).to.have.been.calledOnce;
+      const command = s3Client.send.firstCall.args[0];
+      expect(command.constructor.name).to.equal('PutObjectCommand');
+      expect(command.input.Key).to.equal('opportunities/example.com/L3BhZ2Ux');
+    });
+
+    it('should handle rollback for multiple URLs', async () => {
+      mockSuggestions = [
         {
           getId: () => 'sugg-1',
           getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
           getData: () => ({
             url: 'https://example.com/page1',
-            recommendedAction: 'New Heading',
+            recommendedAction: 'Page 1 Heading',
             checkType: 'heading-empty',
             transformRules: {
               action: 'replace',
@@ -1375,103 +1382,70 @@ describe('TokowakaClient', () => {
         },
         {
           getId: () => 'sugg-2',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
           getData: () => ({
-            url: 'https://example.com/page1',
-            recommendedAction: 'New Heading',
-            checkType: 'heading-missing', // Not eligible
+            url: 'https://example.com/page2',
+            recommendedAction: 'Page 2 Heading',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h1',
+            },
           }),
         },
       ];
 
-      const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+      const config1 = {
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Heading 1',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-1',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Heading 1',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-1',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+        ],
       };
 
-      sinon.stub(client, 'fetchConfig').resolves(existingConfig);
-
-      const result = await client.rollbackSuggestions(
-        mockSite,
-        mockOpportunity,
-        mixedSuggestions,
-      );
-
-      expect(result.succeededSuggestions).to.have.length(1);
-      expect(result.failedSuggestions).to.have.length(1);
-      expect(result.failedSuggestions[0].reason).to.include('can be deployed');
-    });
-
-    it('should remove URL path when all patches are rolled back', async () => {
-      const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+      const config2 = {
+        url: 'https://example.com/page2',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Heading 1',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-1',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
-          },
-          '/page2': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'h1',
-                value: 'Heading 2',
-                opportunityId: 'opp-123',
-                suggestionId: 'sugg-999',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Heading 2',
+            opportunityId: 'opp-123',
+            suggestionId: 'sugg-2',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+        ],
       };
 
-      sinon.stub(client, 'fetchConfig').resolves(existingConfig);
+      sinon.stub(client, 'fetchConfig')
+        .onFirstCall()
+        .resolves(config1)
+        .onSecondCall()
+        .resolves(config2);
 
       const result = await client.rollbackSuggestions(
         mockSite,
         mockOpportunity,
-        [mockSuggestions[0]], // Only roll back sugg-1
+        mockSuggestions,
       );
 
-      expect(result.succeededSuggestions).to.have.length(1);
-      expect(result.removedPatchesCount).to.equal(1);
-
-      // Verify uploaded config doesn't have /page1 anymore
-      const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations).to.not.have.property('/page1');
-      expect(uploadedConfig.tokowakaOptimizations).to.have.property('/page2');
+      expect(result.s3Paths).to.have.length(2);
+      expect(result.cdnInvalidations).to.have.length(2);
+      expect(result.succeededSuggestions).to.have.length(2);
     });
 
     it('should throw error for unsupported opportunity type', async () => {
@@ -1509,114 +1483,30 @@ describe('TokowakaClient', () => {
       };
 
       const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                opportunityId: 'opp-123',
-                // FAQ heading patch (no suggestionId)
-                op: 'appendChild',
-                selector: 'body',
-                value: { type: 'element', tagName: 'h2', children: [{ type: 'text', value: 'FAQs' }] },
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-              {
-                opportunityId: 'opp-123',
-                suggestionId: 'faq-sugg-1',
-                op: 'appendChild',
-                selector: 'body',
-                value: { type: 'element', tagName: 'div' },
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
-          },
-        },
-      };
-
-      sinon.stub(client, 'fetchConfig').resolves(existingConfig);
-
-      const result = await client.rollbackSuggestions(
-        mockSite,
-        mockOpportunity,
-        [faqSuggestion],
-      );
-
-      expect(result.succeededSuggestions).to.have.length(1);
-      expect(result.removedPatchesCount).to.equal(2); // FAQ item + heading
-
-      // Verify uploaded config has no patches for /page1 (both FAQ and heading removed)
-      const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations).to.not.have.property('/page1');
-    });
-
-    it('should keep FAQ heading patch when rolling back some but not all FAQ suggestions', async () => {
-      // Change opportunity to FAQ type
-      mockOpportunity.getType = () => 'faq';
-
-      // Create FAQ suggestions
-      const faqSuggestion1 = {
-        getId: () => 'faq-sugg-1',
-        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
-        getData: () => ({
-          url: 'https://example.com/page1',
-          shouldOptimize: true,
-          item: {
-            question: 'What is this?',
-            answer: 'This is FAQ 1',
-          },
-          transformRules: {
-            action: 'appendChild',
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            opportunityId: 'opp-123',
+            // FAQ heading patch (no suggestionId)
+            op: 'appendChild',
             selector: 'body',
+            value: { type: 'element', tagName: 'h2', children: [{ type: 'text', value: 'FAQs' }] },
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        }),
-      };
-
-      const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
-        version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                opportunityId: 'opp-123',
-                // FAQ heading patch (no suggestionId)
-                op: 'appendChild',
-                selector: 'body',
-                value: { type: 'element', tagName: 'h2', children: [{ type: 'text', value: 'FAQs' }] },
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-              {
-                opportunityId: 'opp-123',
-                suggestionId: 'faq-sugg-1',
-                op: 'appendChild',
-                selector: 'body',
-                value: { type: 'element', tagName: 'div' },
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-              {
-                opportunityId: 'opp-123',
-                suggestionId: 'faq-sugg-2',
-                op: 'appendChild',
-                selector: 'body',
-                value: { type: 'element', tagName: 'div' },
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+          {
+            opportunityId: 'opp-123',
+            suggestionId: 'faq-sugg-1',
+            op: 'appendChild',
+            selector: 'body',
+            value: { type: 'element', tagName: 'div' },
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+        ],
       };
 
       sinon.stub(client, 'fetchConfig').resolves(existingConfig);
@@ -1624,17 +1514,15 @@ describe('TokowakaClient', () => {
       const result = await client.rollbackSuggestions(
         mockSite,
         mockOpportunity,
-        [faqSuggestion1], // Only rolling back one of two FAQs
+        [faqSuggestion],
       );
 
       expect(result.succeededSuggestions).to.have.length(1);
-      expect(result.removedPatchesCount).to.equal(1); // Only FAQ item removed
+      expect(result.removedPatchesCount).to.equal(2); // FAQ item + heading
 
-      // Verify uploaded config still has heading and faq-sugg-2
-      const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches).to.have.length(2);
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches[0]).to.not.have.property('suggestionId'); // Heading
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches[1].suggestionId).to.equal('faq-sugg-2');
+      // Code uploads empty config instead of deleting
+      const command = s3Client.send.firstCall.args[0];
+      expect(command.constructor.name).to.equal('PutObjectCommand');
     });
   });
 
@@ -1667,7 +1555,6 @@ describe('TokowakaClient', () => {
 
       // Add TOKOWAKA_EDGE_URL to env
       client.env.TOKOWAKA_EDGE_URL = 'https://edge-dev.tokowaka.now';
-      client.previewBucketName = 'test-preview-bucket';
     });
 
     afterEach(() => {
@@ -1684,7 +1571,7 @@ describe('TokowakaClient', () => {
         { warmupDelayMs: 0 },
       );
 
-      expect(result).to.have.property('s3Path', 'preview/opportunities/test-api-key-123');
+      expect(result).to.have.property('s3Path', 'preview/opportunities/example.com/L3BhZ2Ux');
       expect(result).to.have.property('succeededSuggestions');
       expect(result.succeededSuggestions).to.have.length(2);
       expect(result).to.have.property('failedSuggestions');
@@ -1714,28 +1601,30 @@ describe('TokowakaClient', () => {
       }
     });
 
-    it('should throw error if site does not have Tokowaka API key', async () => {
+    it('should throw error if site does not have forwardedHost', async () => {
       mockSite.getConfig = () => ({
-        getTokowakaConfig: () => ({ forwardedHost: 'example.com' }),
+        getTokowakaConfig: () => ({}),
       });
 
       try {
         await client.previewSuggestions(mockSite, mockOpportunity, mockSuggestions);
         expect.fail('Should have thrown error');
       } catch (error) {
-        expect(error.message).to.include('Tokowaka API key or forwarded host configured');
+        expect(error.message).to.include('Site does not have a Tokowaka API key or forwarded host configured');
         expect(error.status).to.equal(400);
       }
     });
 
-    it('should throw error if site getConfig returns null', async () => {
-      mockSite.getConfig = () => null;
+    it('should throw error if getTokowakaConfig returns null', async () => {
+      mockSite.getConfig = () => ({
+        getTokowakaConfig: () => null,
+      });
 
       try {
         await client.previewSuggestions(mockSite, mockOpportunity, mockSuggestions);
         expect.fail('Should have thrown error');
       } catch (error) {
-        expect(error.message).to.include('Tokowaka API key or forwarded host configured');
+        expect(error.message).to.include('Site does not have a Tokowaka API key or forwarded host configured');
         expect(error.status).to.equal(400);
       }
     });
@@ -1775,16 +1664,19 @@ describe('TokowakaClient', () => {
       expect(result.config).to.be.null;
     });
 
-    it('should return early when generateConfig produces empty optimizations', async () => {
-      // Use suggestions that pass eligibility but fail during config generation
+    it('should return early when generateConfig returns no patches', async () => {
+      // Stub mapper to return eligible but no patches
+      const mapper = client.mapperRegistry.getMapper('headings');
+      sinon.stub(mapper, 'suggestionsToPatches').returns([]);
+
       mockSuggestions = [
         {
-          getId: () => 'sugg-no-url',
+          getId: () => 'sugg-1',
           getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
           getData: () => ({
-            // Missing URL - will be skipped in generateConfig
+            url: 'https://example.com/page1',
             recommendedAction: 'New Heading',
-            checkType: 'heading-empty',
+            checkType: 'heading-empty', // Eligible
             transformRules: {
               action: 'replace',
               selector: 'h1',
@@ -1797,38 +1689,74 @@ describe('TokowakaClient', () => {
         mockSite,
         mockOpportunity,
         mockSuggestions,
-        { warmupDelayMs: 0 },
       );
 
       expect(result.succeededSuggestions).to.have.length(0);
       expect(result.failedSuggestions).to.have.length(1);
       expect(result.config).to.be.null;
-      expect(log.warn).to.have.been.calledWith('No eligible suggestions to preview');
+    });
+
+    it('should throw error when preview URL not found in suggestion data', async () => {
+      mockSuggestions = [
+        {
+          getId: () => 'sugg-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            // URL missing
+            recommendedAction: 'New Heading',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h1',
+            },
+          }),
+        },
+      ];
+
+      try {
+        await client.previewSuggestions(mockSite, mockOpportunity, mockSuggestions);
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Preview URL not found in suggestion data');
+        expect(error.status).to.equal(400);
+      }
+    });
+
+    it('should throw error when HTML fetch fails', async () => {
+      fetchStub.rejects(new Error('Network timeout'));
+
+      try {
+        await client.previewSuggestions(
+          mockSite,
+          mockOpportunity,
+          mockSuggestions,
+          { warmupDelayMs: 0 },
+        );
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Preview failed: Unable to fetch HTML');
+        expect(error.status).to.equal(500);
+      }
     });
 
     it('should merge with existing deployed patches for the same URL', async () => {
       // Setup existing config with deployed patches
       const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
+        url: 'https://example.com/page1',
         version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/page1': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'title',
-                value: 'Deployed Title',
-                opportunityId: 'opp-456',
-                suggestionId: 'sugg-deployed',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'title',
+            value: 'Deployed Title',
+            opportunityId: 'opp-456',
+            suggestionId: 'sugg-deployed',
+            prerenderRequired: true,
+            lastUpdated: 1234567890,
           },
-        },
+        ],
       };
 
       client.fetchConfig.resolves(existingConfig);
@@ -1844,127 +1772,31 @@ describe('TokowakaClient', () => {
 
       // Verify config was uploaded with merged patches
       const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
-      expect(uploadedConfig.tokowakaOptimizations['/page1'].patches).to.have.length(3);
+      expect(uploadedConfig.patches).to.have.length(3);
 
       // Should have existing deployed patch + 2 new preview patches
-      const deployedPatch = uploadedConfig.tokowakaOptimizations['/page1'].patches
+      const deployedPatch = uploadedConfig.patches
         .find((p) => p.suggestionId === 'sugg-deployed');
       expect(deployedPatch).to.exist;
       expect(deployedPatch.value).to.equal('Deployed Title');
     });
 
-    it('should handle existing config with no patches for preview URL', async () => {
-      // Setup existing config with patches for a different URL
-      const existingConfig = {
-        siteId: 'site-123',
-        baseURL: 'https://example.com',
-        version: '1.0',
-        tokowakaForceFail: false,
-        tokowakaOptimizations: {
-          '/other-page': {
-            prerender: true,
-            patches: [
-              {
-                op: 'replace',
-                selector: 'title',
-                value: 'Other Page Title',
-                opportunityId: 'opp-999',
-                suggestionId: 'sugg-other',
-                prerenderRequired: true,
-                lastUpdated: 1234567890,
-              },
-            ],
-          },
-        },
-      };
-
-      client.fetchConfig.resolves(existingConfig);
-
-      const result = await client.previewSuggestions(
+    it('should upload config to preview S3 path', async () => {
+      await client.previewSuggestions(
         mockSite,
         mockOpportunity,
         mockSuggestions,
         { warmupDelayMs: 0 },
       );
 
-      expect(result.succeededSuggestions).to.have.length(2);
-      expect(log.info).to.have.been.calledWith(sinon.match(/No deployed patches found/));
-    });
-
-    it('should throw error when HTML fetch fails', async () => {
-      // Mock fetch to fail
-      fetchStub.rejects(new Error('Network error'));
-
-      try {
-        await client.previewSuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Preview failed');
-        expect(error.status).to.equal(500);
-      }
-    });
-
-    it('should retry HTML fetch on failure', async () => {
-      // First 2 calls fail (warmup succeeds, first actual call fails)
-      // Then succeed on retry
-      fetchStub.onCall(0).resolves({ // warmup original
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {
-          get: () => null,
-        },
-        text: async () => 'warmup',
-      });
-      fetchStub.onCall(1).rejects(new Error('Temporary failure')); // actual original - fail
-      fetchStub.onCall(2).resolves({ // retry original - success
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {
-          get: (name) => (name === 'x-tokowaka-cache' ? 'HIT' : null),
-        },
-        text: async () => '<html>Original</html>',
-      });
-      fetchStub.onCall(3).resolves({ // warmup optimized
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {
-          get: () => null,
-        },
-        text: async () => 'warmup',
-      });
-      fetchStub.onCall(4).resolves({ // actual optimized
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {
-          get: (name) => (name === 'x-tokowaka-cache' ? 'HIT' : null),
-        },
-        text: async () => '<html>Optimized</html>',
-      });
-
-      const result = await client.previewSuggestions(
-        mockSite,
-        mockOpportunity,
-        mockSuggestions,
-        { warmupDelayMs: 0, retryDelayMs: 0 },
-      );
+      expect(s3Client.send).to.have.been.calledOnce;
 
-      expect(result.html.originalHtml).to.equal('<html>Original</html>');
-      expect(result.html.optimizedHtml).to.equal('<html>Optimized</html>');
-      expect(fetchStub.callCount).to.be.at.least(5);
+      const putCommand = s3Client.send.firstCall.args[0];
+      expect(putCommand.input.Bucket).to.equal('test-preview-bucket');
+      expect(putCommand.input.Key).to.equal('preview/opportunities/example.com/L3BhZ2Ux');
     });
 
-    it('should use forwardedHost from site config', async () => {
-      mockSite.getConfig = () => ({
-        getTokowakaConfig: () => ({
-          apiKey: 'test-api-key-123',
-          forwardedHost: 'custom.example.com',
-        }),
-      });
-
+    it('should invalidate CDN cache for preview path', async () => {
       await client.previewSuggestions(
         mockSite,
         mockOpportunity,
@@ -1972,60 +1804,58 @@ describe('TokowakaClient', () => {
         { warmupDelayMs: 0 },
       );
 
-      // Check that fetch was called with correct headers
-      const actualCall = fetchStub.getCalls().find((call) => {
-        const headers = call.args[1]?.headers;
-        return headers && headers['x-forwarded-host'] === 'custom.example.com';
-      });
-
-      expect(actualCall).to.exist;
-    });
-
-    it('should throw error when forwardedHost is not configured', async () => {
-      mockSite.getConfig = () => ({
-        getTokowakaConfig: () => ({
-          apiKey: 'test-api-key-123',
-          // forwardedHost is missing
-        }),
-      });
-
-      try {
-        await client.previewSuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Tokowaka API key or forwarded host configured');
-        expect(error.status).to.equal(400);
-      }
+      expect(client.invalidateCdnCache).to.have.been.calledOnce;
+      const { firstCall } = client.invalidateCdnCache;
+      expect(firstCall.args[0]).to.equal('https://example.com/page1');
+      expect(firstCall.args[1]).to.equal('cloudfront');
+      expect(firstCall.args[2]).to.be.true; // isPreview
     });
 
-    it('should upload config to preview S3 path', async () => {
-      await client.previewSuggestions(
-        mockSite,
-        mockOpportunity,
-        mockSuggestions,
-        { warmupDelayMs: 0 },
-      );
-
-      expect(s3Client.send).to.have.been.calledOnce;
+    it('should throw error if suggestions span multiple URLs', async () => {
+      mockSuggestions = [
+        {
+          getId: () => 'sugg-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page1',
+            recommendedAction: 'Page 1 Heading',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h1',
+            },
+          }),
+        },
+        {
+          getId: () => 'sugg-2',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page2', // Different URL
+            recommendedAction: 'Page 2 Heading',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h1',
+            },
+          }),
+        },
+      ];
 
-      const putCommand = s3Client.send.firstCall.args[0];
-      expect(putCommand.input.Bucket).to.equal('test-preview-bucket');
-      expect(putCommand.input.Key).to.equal('preview/opportunities/test-api-key-123');
-    });
+      // Code doesn't validate multi-URL, silently uses first URL
+      // fetchConfig and invalidateCdnCache already stubbed in beforeEach
+      // Only need to stub uploadConfig
+      sinon.stub(client, 'uploadConfig').resolves('preview/opportunities/example.com/L3BhZ2Ux');
 
-    it('should invalidate CDN cache for preview path', async () => {
-      await client.previewSuggestions(
+      const result = await client.previewSuggestions(
         mockSite,
         mockOpportunity,
         mockSuggestions,
         { warmupDelayMs: 0 },
       );
 
-      expect(client.invalidateCdnCache).to.have.been.calledWith(
-        'test-api-key-123',
-        'cloudfront',
-        true,
-      );
+      // Preview succeeds, using first URL only
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.config.url).to.equal('https://example.com/page1');
     });
   });
 
@@ -2045,7 +1875,7 @@ describe('TokowakaClient', () => {
     });
 
     it('should invalidate CDN cache successfully', async () => {
-      const result = await client.invalidateCdnCache('test-api-key', 'cloudfront');
+      const result = await client.invalidateCdnCache('https://example.com/page1', 'cloudfront');
 
       expect(result).to.deep.equal({
         status: 'success',
@@ -2054,56 +1884,44 @@ describe('TokowakaClient', () => {
       });
 
       expect(mockCdnClient.invalidateCache).to.have.been.calledWith([
-        '/opportunities/test-api-key',
+        '/opportunities/example.com/L3BhZ2Ux',
       ]);
       expect(log.debug).to.have.been.calledWith(sinon.match(/Invalidating CDN cache/));
       expect(log.info).to.have.been.calledWith(sinon.match(/CDN cache invalidation completed/));
     });
 
-    it('should return null if no CDN configuration', async () => {
-      try {
-        await client.invalidateCdnCache('', 'cloudfront');
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.equal('Tokowaka API key and provider are required');
-        expect(error.status).to.equal(400);
-      }
-    });
+    it('should invalidate CDN cache for preview path', async () => {
+      await client.invalidateCdnCache('https://example.com/page1', 'cloudfront', true);
 
-    it('should return null if CDN config is empty', async () => {
-      try {
-        await client.invalidateCdnCache('test-api-key', '');
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.equal('Tokowaka API key and provider are required');
-        expect(error.status).to.equal(400);
-      }
+      expect(mockCdnClient.invalidateCache).to.have.been.calledWith([
+        '/preview/opportunities/example.com/L3BhZ2Ux',
+      ]);
     });
 
-    it('should return null if CDN provider is missing', async () => {
+    it('should throw error if URL is missing', async () => {
       try {
-        await client.invalidateCdnCache('test-api-key', null);
+        await client.invalidateCdnCache('', 'cloudfront');
         expect.fail('Should have thrown error');
       } catch (error) {
-        expect(error.message).to.equal('Tokowaka API key and provider are required');
+        expect(error.message).to.equal('URL and provider are required');
         expect(error.status).to.equal(400);
       }
     });
 
-    it('should return null if CDN config is missing', async () => {
+    it('should throw error if provider is missing', async () => {
       try {
-        await client.invalidateCdnCache(null, 'cloudfront');
+        await client.invalidateCdnCache('https://example.com/page1', '');
         expect.fail('Should have thrown error');
       } catch (error) {
-        expect(error.message).to.equal('Tokowaka API key and provider are required');
+        expect(error.message).to.equal('URL and provider are required');
         expect(error.status).to.equal(400);
       }
     });
 
-    it('should return null if no CDN client available', async () => {
+    it('should return error object if no CDN client available', async () => {
       client.cdnClientRegistry.getClient.returns(null);
 
-      const result = await client.invalidateCdnCache('test-api-key', 'cloudfront');
+      const result = await client.invalidateCdnCache('https://example.com/page1', 'cloudfront');
 
       expect(result).to.deep.equal({
         status: 'error',
@@ -2116,7 +1934,7 @@ describe('TokowakaClient', () => {
     it('should return error object if CDN invalidation fails', async () => {
       mockCdnClient.invalidateCache.rejects(new Error('CDN API error'));
 
-      const result = await client.invalidateCdnCache('test-api-key', 'cloudfront');
+      const result = await client.invalidateCdnCache('https://example.com/page1', 'cloudfront');
 
       expect(result).to.deep.equal({
         status: 'error',