@mj-biz-apps/marketing-server 0.6.0 → 0.7.0

package/dist/__tests__/adConversionParity.test.js

@@ -1,5 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { GoogleAdsClient } from '../programs/google/GoogleAdsClient.js';
+import { buildGoogleCampaignTargetingState, GoogleAdsProgramDriver } from '../programs/google/GoogleAdsProgramDriver.js';
+import { LinkedInAdsClient, linkedInConversionTypeFor } from '../programs/linkedin/LinkedInAdsClient.js';
+import { LinkedInAdsProgramDriver } from '../programs/linkedin/LinkedInAdsProgramDriver.js';
 import { MetaAdsClient, customConversionActionType, metaCallToActionFor, metaObjectiveFor } from '../programs/meta/MetaAdsClient.js';
 import { MetaAdsProgramDriver } from '../programs/meta/MetaAdsProgramDriver.js';
 function googleClient(answer) {
@@ -37,11 +40,17 @@ describe('GoogleAdsClient — conversion actions (D-34 parity)', () => {
         const create = calls.find(c => c.url.includes('customConversionGoals:mutate'));
         expect(JSON.parse(String(create.init?.body))).toEqual({ operations: [{ create: { name: 'Marketing: Ascend Book Download - Google - Form Submission', conversionActions: ['customers/4684433735/conversionActions/7845520214'], status: 'ENABLED' } }] });
         await client.setCampaignConversionGoal('customers/4684433735/campaigns/24313683017', goal);
-        const point = calls.find(c => c.url.includes('conversionGoalCampaignConfigs:mutate'));
-        expect(JSON.parse(String(point.init?.body))).toEqual({ operations: [{
+        const goalConfigCalls = calls.filter(c => c.url.includes('conversionGoalCampaignConfigs:mutate'));
+        expect(JSON.parse(String(goalConfigCalls[0].init?.body))).toEqual({ operations: [{
                     update: { resourceName: 'customers/4684433735/conversionGoalCampaignConfigs/24313683017', goalConfigLevel: 'CAMPAIGN', customConversionGoal: goal },
                     updateMask: 'goal_config_level,custom_conversion_goal',
                 }] });
+        await client.useCustomerConversionGoals('customers/4684433735/campaigns/24313683017');
+        const customerGoalCalls = calls.filter(c => c.url.includes('conversionGoalCampaignConfigs:mutate'));
+        expect(JSON.parse(String(customerGoalCalls[1].init?.body))).toEqual({ operations: [{
+                    update: { resourceName: 'customers/4684433735/conversionGoalCampaignConfigs/24313683017', goalConfigLevel: 'CUSTOMER' },
+                    updateMask: 'goal_config_level',
+                }] });
         // Google allows ONE goal per action list on the customer: an existing goal holding exactly this action is reused
         // as is (whoever made it, whatever its name), a goal holding more actions is not a match.
         const { client: adoptingClient, calls: adoptCalls } = googleClient(() => [{ results: [
@@ -63,7 +72,7 @@ describe('GoogleAdsClient — conversion actions (D-34 parity)', () => {
         const queries = calls.filter(c => c.url.includes('searchStream')).map(queryOf);
         expect(queries).toHaveLength(2);
         expect(queries[0]).not.toContain('segments.conversion_action');
-        expect(queries[1]).toContain("SELECT metrics.all_conversions FROM campaign WHERE campaign.resource_name IN ('customers/4684433735/campaigns/1') AND segments.date BETWEEN '2026-10-01' AND '2026-10-14' AND segments.conversion_action = 'customers/4684433735/conversionActions/7845520214'");
+        expect(queries[1]).toContain("SELECT segments.conversion_action, metrics.all_conversions FROM campaign WHERE campaign.resource_name IN ('customers/4684433735/campaigns/1') AND segments.date BETWEEN '2026-10-01' AND '2026-10-14' AND segments.conversion_action = 'customers/4684433735/conversionActions/7845520214'");
         const plain = await client.campaignMetrics(['customers/4684433735/campaigns/1'], new Date('2026-10-01T00:00:00Z'), new Date('2026-10-14T00:00:00Z'));
         expect(plain.conversions).toBe(0);
         expect(calls.filter(c => c.url.includes('searchStream'))).toHaveLength(3);
@@ -248,10 +257,555 @@ describe('GoogleAdsClient — user lists, geo targeting, and schedule dates (KI-
         const createBody = JSON.parse(String(calls[1].init?.body));
         expect(createBody.operations[0].create['startDate']).toBe('2026-11-01');
         expect(createBody.operations[0].create['endDate']).toBe('2026-11-15');
+        expect(createBody.operations[0].create['targetSpend']).toEqual({ cpcBidCeilingMicros: '2000000' });
+        expect(createBody.operations[0].create['geoTargetTypeSetting']).toEqual({ positiveGeoTargetType: 'PRESENCE' });
         await client.setCampaignSchedule('customers/4684433735/campaigns/99', { start, end: new Date('2026-11-22T00:00:00Z').getTime() });
         const updateBody = JSON.parse(String(calls[2].init?.body));
         expect(updateBody.operations[0].update['endDate']).toBe('2026-11-22');
         expect(updateBody.operations[0].updateMask).toContain('end_date');
     });
+    it('attaches multi-location, language, and negative mobile-app criteria idempotently and updates delivery settings (D-37, KI-164)', async () => {
+        const { client, calls } = googleClient((url, body) => {
+            if (url.includes('campaignCriteria:mutate') || url.includes('campaigns:mutate')) {
+                return { results: [{ resourceName: 'customers/4684433735/campaignCriteria/99~1' }] };
+            }
+            const q = body.query;
+            if (q.includes('campaign_criterion.location.geo_target_constant')) {
+                return [{ results: [{ campaignCriterion: { location: { geoTargetConstant: 'geoTargetConstants/2840' } } }] }];
+            }
+            return [];
+        });
+        await client.attachCampaignLocations('customers/4684433735/campaigns/99', ['geoTargetConstants/2840', 'geoTargetConstants/2124']);
+        const locMutate = calls.find(c => c.url.includes('campaignCriteria:mutate'));
+        expect(JSON.parse(String(locMutate.init?.body))).toEqual({
+            operations: [{ create: { campaign: 'customers/4684433735/campaigns/99', location: { geoTargetConstant: 'geoTargetConstants/2124' } } }],
+        });
+        await client.attachCampaignLanguages('customers/4684433735/campaigns/99', ['languageConstants/1000']);
+        const criteriaMutates = calls.filter(c => c.url.includes('campaignCriteria:mutate'));
+        expect(JSON.parse(String(criteriaMutates[1].init?.body))).toEqual({
+            operations: [{ create: { campaign: 'customers/4684433735/campaigns/99', language: { languageConstant: 'languageConstants/1000' } } }],
+        });
+        await client.excludeCampaignMobileApps('customers/4684433735/campaigns/99');
+        const criteriaMutatesAfterExclude = calls.filter(c => c.url.includes('campaignCriteria:mutate'));
+        expect(JSON.parse(String(criteriaMutatesAfterExclude[2].init?.body))).toEqual({
+            operations: [{
+                    create: {
+                        campaign: 'customers/4684433735/campaigns/99',
+                        negative: true,
+                        mobileAppCategory: { mobileAppCategoryConstant: 'mobileAppCategoryConstants/69500' },
+                    },
+                }],
+        });
+        await client.updateCampaignDeliverySettings('customers/4684433735/campaigns/99', { maxCpcUsd: 2 });
+        const campaignMutates = calls.filter(c => c.url.includes('campaigns:mutate'));
+        expect(JSON.parse(String(campaignMutates[0].init?.body))).toEqual({
+            operations: [{
+                    update: {
+                        resourceName: 'customers/4684433735/campaigns/99',
+                        targetSpend: { cpcBidCeilingMicros: '2000000' },
+                        geoTargetTypeSetting: { positiveGeoTargetType: 'PRESENCE' },
+                    },
+                    updateMask: 'target_spend.cpc_bid_ceiling_micros,geo_target_type_setting.positive_geo_target_type',
+                }],
+        });
+        await client.setCampaignMaximizeConversions('customers/4684433735/campaigns/99');
+        const campaignMutatesAfterMaxConv = calls.filter(c => c.url.includes('campaigns:mutate'));
+        expect(JSON.parse(String(campaignMutatesAfterMaxConv[1].init?.body))).toEqual({
+            operations: [{
+                    update: {
+                        resourceName: 'customers/4684433735/campaigns/99',
+                        maximizeConversions: {},
+                    },
+                    updateMask: 'maximize_conversions',
+                }],
+        });
+        expect(buildGoogleCampaignTargetingState({
+            maxCpcUsd: 2,
+            locationsAttached: ['geoTargetConstants/2840', 'geoTargetConstants/2124'],
+            languagesAttached: ['languageConstants/1000'],
+            mobileAppsExcluded: true,
+        })).toEqual({
+            bidding: 'TARGET_SPEND',
+            maxCpcUsd: 2,
+            positiveGeoTargetType: 'PRESENCE',
+            locationsAttached: ['geoTargetConstants/2840', 'geoTargetConstants/2124'],
+            languagesAttached: ['languageConstants/1000'],
+            mobileAppsExcluded: true,
+        });
+    });
+    it('emits notice-level parity issues when Google-only targeting/bidding levers are passed to LinkedIn or Meta (D-37)', async () => {
+        const tacticConfigJSON = JSON.stringify({
+            audience: 'targeted',
+            dailyBudgetUsd: 25,
+            maxCpcUsd: 2,
+            locations: ['US', 'CA'],
+            languages: ['en'],
+            landingPageUrl: 'https://example.org/ai',
+            optimizeFor: 'clicks',
+            creativeHeadlines: ['Master AI Strategy', 'AI Roadmap for Leaders'],
+            creativeDescriptions: ['Download the free ebook.'],
+        });
+        const liDriver = new LinkedInAdsProgramDriver();
+        const liIssues = await liDriver.validateProposal({ id: 'P1', brandId: 'B1', params: { campaignCode: 'CL-01', tacticConfigJSON } });
+        expect(liIssues.map(i => [i.code, i.severity])).toEqual([
+            ['LI_MAX_CPC_IGNORED', 'notice'],
+            ['LI_LOCATIONS_IN_AUDIENCE', 'notice'],
+            ['LI_LANGUAGES_IN_AUDIENCE', 'notice'],
+        ]);
+        const metaDriver = new MetaAdsProgramDriver();
+        const metaIssues = await metaDriver.validateProposal({ id: 'P2', brandId: 'B1', params: { campaignCode: 'CM-01', tacticConfigJSON } });
+        expect(metaIssues.map(i => [i.code, i.severity])).toEqual([
+            ['MA_MAX_CPC_IGNORED', 'notice'],
+            ['MA_LOCATIONS_IGNORED', 'notice'],
+            ['MA_LANGUAGES_IGNORED', 'notice'],
+        ]);
+    });
+});
+function linkedInClient(answer) {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        const url = String(input);
+        calls.push({ url, init });
+        if (url.endsWith('/accessToken')) {
+            return new Response(JSON.stringify({ access_token: 'li-tok', expires_in: 3600, scope: 'r_ads,rw_ads,r_ads_reporting,rw_dmp_segments,rw_conversions' }), { status: 200 });
+        }
+        const res = answer(url, init);
+        return new Response(res.body === null ? null : JSON.stringify(res.body), {
+            status: res.status ?? 200,
+            headers: res.headers,
+        });
+    });
+    return { client: new LinkedInAdsClient({ clientId: 'c', clientSecret: 's', refreshToken: 'r', adAccountId: '509410093', fetchImpl }), calls };
+}
+describe('LinkedInAdsClient — conversions, URL conversion rules, and pivot=CONVERSION analytics (D-34, KI-148, KI-152)', () => {
+    it('lists conversions, adopts an enabled conversion by name, creates a URL conversion rule, and maps every CTA to LinkedIn ConversionType', async () => {
+        const { client, calls } = linkedInClient((url, init) => {
+            if (init?.method === 'POST' && url.endsWith('/rest/conversions')) {
+                return { status: 201, headers: { 'x-restli-id': '32001001' }, body: {} };
+            }
+            if (init?.method === 'PUT' && url.includes('/rest/campaignConversions/')) {
+                return { status: 204, body: null };
+            }
+            return {
+                body: {
+                    elements: [
+                        { id: 29519276, name: 'SC | Ascend Download', type: 'DOWNLOAD', enabled: true },
+                        { id: 29325716, name: 'CP-04 — lead conversion', type: 'LEAD', enabled: true },
+                        { id: 100, name: 'CP-05 — lead conversion', type: 'LEAD', enabled: false },
+                    ],
+                },
+            };
+        });
+        const list = await client.conversions();
+        expect(list).toEqual([
+            { id: '29519276', urn: 'urn:lla:llaPartnerConversion:29519276', name: 'SC | Ascend Download', type: 'DOWNLOAD', enabled: true },
+            { id: '29325716', urn: 'urn:lla:llaPartnerConversion:29325716', name: 'CP-04 — lead conversion', type: 'LEAD', enabled: true },
+            { id: '100', urn: 'urn:lla:llaPartnerConversion:100', name: 'CP-05 — lead conversion', type: 'LEAD', enabled: false },
+        ]);
+        expect(await client.findConversionById(' 29519276 ')).toMatchObject({ id: '29519276', name: 'SC | Ascend Download' });
+        expect(await client.findConversionByName('CP-04 — lead conversion')).toMatchObject({ id: '29325716', urn: 'urn:lla:llaPartnerConversion:29325716' });
+        // Disabled conversions are not adopted by name
+        expect(await client.findConversionByName('CP-05 — lead conversion')).toBeNull();
+        const created = await client.createUrlConversion({
+            name: 'CP-06 — lead conversion',
+            urlContains: '/ebook-thank-you',
+            type: linkedInConversionTypeFor('DOWNLOAD'),
+        });
+        expect(created).toEqual({
+            id: '32001001',
+            urn: 'urn:lla:llaPartnerConversion:32001001',
+            name: 'CP-06 — lead conversion',
+            type: 'DOWNLOAD',
+            enabled: true,
+        });
+        const postCall = calls.find(c => c.init?.method === 'POST' && c.url.endsWith('/rest/conversions'));
+        expect(JSON.parse(String(postCall.init?.body))).toEqual({
+            account: 'urn:li:sponsoredAccount:509410093',
+            name: 'CP-06 — lead conversion',
+            type: 'DOWNLOAD',
+            conversionMethod: 'INSIGHT_TAG_URL_MATCH_RULES',
+            postClickAttributionWindowSize: 30,
+            viewThroughAttributionWindowSize: 7,
+            attributionType: 'LAST_TOUCH_BY_CONVERSION',
+            urlMatchRuleExpression: [[{ matchType: 'CONTAINS', matchValue: '/ebook-thank-you' }]],
+        });
+        await client.associateConversion('urn:li:sponsoredCampaign:919676896', created.urn);
+        const putCall = calls.find(c => c.init?.method === 'PUT' && c.url.includes('/rest/campaignConversions/'));
+        expect(putCall.url).toContain('(campaign:urn%3Ali%3AsponsoredCampaign%3A919676896,conversion:urn%3Alla%3AllaPartnerConversion%3A32001001)');
+        let putAttempts = 0;
+        const { client: retryClient } = linkedInClient((url) => {
+            if (url.includes('/rest/campaignConversions/')) {
+                putAttempts++;
+                if (putAttempts === 1)
+                    return { status: 404, body: { message: 'Requester does not have permission to UPDATE the resource.', status: 404 } };
+                return { status: 204, body: null };
+            }
+            return { body: { elements: [] } };
+        });
+        await retryClient.associateConversion('urn:li:sponsoredCampaign:898478323', created.urn, [1]);
+        expect(putAttempts).toBe(2);
+        expect(linkedInConversionTypeFor('DOWNLOAD')).toBe('DOWNLOAD');
+        expect(linkedInConversionTypeFor('REGISTER')).toBe('REGISTER_EVENT');
+        expect(linkedInConversionTypeFor('ATTEND')).toBe('REGISTER_EVENT');
+        expect(linkedInConversionTypeFor('SUBSCRIBE')).toBe('SUBSCRIBE');
+        expect(linkedInConversionTypeFor('SIGN_UP')).toBe('SIGN_UP');
+        expect(linkedInConversionTypeFor('JOIN')).toBe('SIGN_UP');
+        expect(linkedInConversionTypeFor('VIEW_QUOTE')).toBe('REQUEST_QUOTE');
+        expect(linkedInConversionTypeFor('REQUEST_DEMO')).toBe('LEAD');
+        expect(linkedInConversionTypeFor('LEARN_MORE')).toBe('LEAD');
+        expect(linkedInConversionTypeFor(null)).toBe('LEAD');
+    });
+    it('scopes externalWebsiteConversions via pivot=CONVERSION when conversionId is provided, and uses pivot=CAMPAIGN alone for clicks programs (D-34 addendum)', async () => {
+        const { client, calls } = linkedInClient((url) => {
+            if (url.includes('pivot=CONVERSION')) {
+                return {
+                    body: {
+                        elements: [
+                            { externalWebsiteConversions: 5, pivotValues: ['urn:lla:llaPartnerConversion:25692636'] },
+                            { externalWebsiteConversions: 2, pivotValues: ['urn:lla:llaPartnerConversion:29519276'] },
+                            { externalWebsiteConversions: 1, pivotValues: ['urn:lla:llaPartnerConversion:18994420'] },
+                        ],
+                    },
+                };
+            }
+            return {
+                body: {
+                    elements: [
+                        { impressions: 1400, clicks: 35, landingPageClicks: 28, externalWebsiteConversions: 8, costInLocalCurrency: '42.75' },
+                    ],
+                },
+            };
+        });
+        const scoped = await client.campaignAnalytics(['urn:li:sponsoredCampaign:919676896'], new Date('2026-11-01T00:00:00Z'), new Date('2026-11-15T00:00:00Z'), '29519276');
+        expect(scoped).toEqual({
+            impressions: 1400,
+            clicks: 35,
+            landingPageClicks: 28,
+            externalWebsiteConversions: 2,
+            spendUsd: 42.75,
+        });
+        const analyticsCalls = calls.filter(c => c.url.includes('/adAnalytics'));
+        expect(analyticsCalls).toHaveLength(2);
+        expect(analyticsCalls[0].url).toContain('pivot=CAMPAIGN');
+        expect(analyticsCalls[1].url).toContain('pivot=CONVERSION');
+        expect(analyticsCalls[1].url).toContain('fields=externalWebsiteConversions,pivotValues');
+        const unsegmented = await client.campaignAnalytics(['urn:li:sponsoredCampaign:919676896'], new Date('2026-11-01T00:00:00Z'), new Date('2026-11-15T00:00:00Z'));
+        expect(unsegmented.externalWebsiteConversions).toBe(8);
+        expect(calls.filter(c => c.url.includes('/adAnalytics'))).toHaveLength(3);
+    });
+    it('refuses conversionRule on Google Ads with GA_CONVERSION_RULE_UNSUPPORTED (driver parity)', async () => {
+        const gDriver = new GoogleAdsProgramDriver();
+        const tacticConfigJSON = JSON.stringify({
+            audience: 'targeted',
+            dailyBudgetUsd: 25,
+            landingPageUrl: 'https://example.org/ai',
+            conversionRule: '/ebook-thank-you',
+            creativeHeadlines: ['Master AI Strategy'],
+            creativeDescriptions: ['Download the free ebook.'],
+        });
+        const issues = await gDriver.validateProposal({ id: 'P3', brandId: 'B1', params: { campaignCode: 'CG-05', tacticConfigJSON } });
+        expect(issues.find(i => i.code === 'GA_CONVERSION_RULE_UNSUPPORTED')).toMatchObject({
+            severity: 'error',
+            code: 'GA_CONVERSION_RULE_UNSUPPORTED',
+        });
+    });
+    it('detaches a conversion via DELETE /campaignConversions and treats 404 as already detached', async () => {
+        let count = 0;
+        const { client, calls } = linkedInClient((url, init) => {
+            if (init?.method === 'DELETE' && url.includes('/rest/campaignConversions/')) {
+                count += 1;
+                return count === 1 ? { status: 204, body: null } : { status: 404, body: { message: 'Not found' } };
+            }
+            return { body: {} };
+        });
+        await client.disassociateConversion('urn:li:sponsoredCampaign:910066056', 'urn:lla:llaPartnerConversion:18994420');
+        await client.disassociateConversion('urn:li:sponsoredCampaign:910066056', 'urn:lla:llaPartnerConversion:18994420');
+        const deletes = calls.filter(c => c.init?.method === 'DELETE');
+        expect(deletes).toHaveLength(2);
+        expect(deletes[0].url).toContain('/rest/campaignConversions/(campaign:urn%3Ali%3AsponsoredCampaign%3A910066056,conversion:urn%3Alla%3AllaPartnerConversion%3A18994420)');
+    });
+    it('attaches connection trackingConversions on LinkedIn lock without changing state.conversion or optimizeFor, and detaches removed standing conversions on re-lock', async () => {
+        const associated = [];
+        const disassociated = [];
+        const savedRefs = [];
+        const fakeUser = { ID: 'u1' };
+        let currentTracking = [
+            { ID: '30316052', Name: 'Self-Serve Checkout' },
+            { ID: '29325716', Name: 'Demo Form Submit' },
+        ];
+        const driver = new LinkedInAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-li',
+            adAccountId: '509410093',
+            launchState: 'Paused',
+            organizationUrn: 'urn:li:organization:900001',
+            defaultAudienceTemplateId: '70217227',
+            trackingConversions: currentTracking,
+            client: {
+                accountReference: async () => 'urn:li:organization:900001',
+                tokenScopes: async () => ['r_ads', 'rw_ads', 'rw_conversions'],
+                conversions: async () => [
+                    { id: '30316052', urn: 'urn:lla:llaPartnerConversion:30316052', name: 'Self-Serve Checkout', type: 'PURCHASE', enabled: true },
+                    { id: '29325716', urn: 'urn:lla:llaPartnerConversion:29325716', name: 'Demo Form Submit', type: 'LEAD', enabled: true },
+                ],
+                findAudienceTemplateById: async () => ({ id: '70217227', name: 'Execs', approximateMemberCount: 50_000, targetingCriteria: {} }),
+                createCampaignGroup: async () => 'urn:li:sponsoredCampaignGroup:1',
+                createCampaign: async () => 'urn:li:sponsoredCampaign:2',
+                associateConversion: async (camp, conv) => { associated.push([camp, conv]); },
+                disassociateConversion: async (camp, conv) => { disassociated.push([camp, conv]); },
+            },
+        }));
+        driver['loadRefs'] = async () => [];
+        driver['runScheduleFor'] = async () => ({ start: 1_800_000_000_000 });
+        driver['saveRef'] = async (_pid, _bc, kind, urn, state) => {
+            savedRefs.push({ kind, urn, state });
+        };
+        const program = {
+            id: 'prog-li-1',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Clicks',
+            params: {
+                campaignCode: 'CP-09',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    optimizeFor: 'clicks',
+                }),
+            },
+        };
+        await driver.onLock(program);
+        expect(associated).toEqual([
+            ['urn:li:sponsoredCampaign:2', 'urn:lla:llaPartnerConversion:30316052'],
+            ['urn:li:sponsoredCampaign:2', 'urn:lla:llaPartnerConversion:29325716'],
+        ]);
+        const campaignRef = savedRefs.find(r => r.kind === 'Campaign');
+        expect(campaignRef?.state).toMatchObject({
+            conversion: null,
+            optimizeFor: 'clicks',
+            objective: 'WEBSITE_VISIT',
+            trackingConversions: [
+                { id: '30316052', name: 'Self-Serve Checkout' },
+                { id: '29325716', name: 'Demo Form Submit' },
+            ],
+        });
+        // Re-lock after removing 29325716 from the connection: detaches 29325716 and updates StateJSON.trackingConversions.
+        associated.length = 0;
+        currentTracking = [{ ID: '30316052', Name: 'Self-Serve Checkout' }];
+        const existingCampaignRow = {
+            ExternalKind: 'Campaign',
+            ExternalURN: 'urn:li:sponsoredCampaign:2',
+            StateJSON: JSON.stringify(campaignRef?.state ?? {}),
+            Save: async () => true,
+        };
+        driver['loadRefs'] = async () => [
+            { ExternalKind: 'CampaignGroup', ExternalURN: 'urn:li:sponsoredCampaignGroup:1', StateJSON: null, Save: async () => true },
+            existingCampaignRow,
+        ];
+        await driver.onLock(program);
+        expect(disassociated).toEqual([
+            ['urn:li:sponsoredCampaign:2', 'urn:lla:llaPartnerConversion:29325716'],
+        ]);
+        expect(associated).toEqual([
+            ['urn:li:sponsoredCampaign:2', 'urn:lla:llaPartnerConversion:30316052'],
+        ]);
+        expect(JSON.parse(existingCampaignRow.StateJSON)).toMatchObject({
+            conversion: null,
+            optimizeFor: 'clicks',
+            trackingConversions: [{ id: '30316052', name: 'Self-Serve Checkout' }],
+        });
+    });
+    it('validates standing conversions at propose, connection save, and BEFORE onLock creates any group or campaign', async () => {
+        const fakeUser = { ID: 'u1' };
+        let scopes = ['r_ads', 'rw_ads', 'rw_conversions'];
+        let groupCreated = false;
+        let campaignCreated = false;
+        const driver = new LinkedInAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-li',
+            adAccountId: '509410093',
+            launchState: 'Paused',
+            organizationUrn: 'urn:li:organization:900001',
+            defaultAudienceTemplateId: '70217227',
+            trackingConversions: [{ ID: '99999999', Name: 'Deleted Conversion' }],
+            client: {
+                accountReference: async () => 'urn:li:organization:900001',
+                tokenScopes: async () => scopes,
+                conversions: async () => [
+                    { id: '30316052', urn: 'urn:lla:llaPartnerConversion:30316052', name: 'Self-Serve Checkout', type: 'PURCHASE', enabled: true },
+                ],
+                findAudienceTemplateById: async () => ({ id: '70217227', name: 'Execs', approximateMemberCount: 50_000, targetingCriteria: {} }),
+                createCampaignGroup: async () => { groupCreated = true; return 'urn:li:sponsoredCampaignGroup:1'; },
+                createCampaign: async () => { campaignCreated = true; return 'urn:li:sponsoredCampaign:2'; },
+            },
+        }));
+        const program = {
+            id: 'prog-li-2',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Clicks',
+            params: {
+                campaignCode: 'CP-10',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    optimizeFor: 'clicks',
+                }),
+            },
+        };
+        // 1. Propose emits LI_CONVERSION_UNKNOWN for unknown standing conversion
+        const unknownIssues = await driver.validateProposal(program);
+        expect(unknownIssues.some(i => i.code === 'LI_CONVERSION_UNKNOWN' && i.severity === 'error')).toBe(true);
+        // 2. onLock throws BEFORE creating CampaignGroup or Campaign (no KI-148 orphan)
+        driver['loadRefs'] = async () => [];
+        await expect(driver.onLock(program)).rejects.toThrow(/no standing conversion with id 99999999/);
+        expect(groupCreated).toBe(false);
+        expect(campaignCreated).toBe(false);
+        // 3. Connection-save helper refuses unknown ID, refuses missing rw_conversions scope, and resolves canonical names when valid
+        const missingRes = await driver.resolveStandingConversions({
+            brandId: 'brand-1',
+            credentialId: 'cred-1',
+            credentialName: 'LinkedIn Cred',
+            externalAccountId: '509410093',
+            requested: [{ ID: '99999999', Name: 'Stale' }],
+        });
+        expect(missingRes).toEqual({
+            ok: false,
+            message: expect.stringContaining('No conversion with id 99999999 on LinkedIn ad account 509410093'),
+        });
+        const validRes = await driver.resolveStandingConversions({
+            brandId: 'brand-1',
+            credentialId: 'cred-1',
+            credentialName: 'LinkedIn Cred',
+            externalAccountId: '509410093',
+            requested: [{ ID: '30316052', Name: 'Caller Typed Label' }],
+        });
+        expect(validRes).toEqual({
+            ok: true,
+            conversions: [{ ID: '30316052', Name: 'Self-Serve Checkout' }],
+        });
+        scopes = ['r_ads', 'rw_ads'];
+        const noScopeRes = await driver.resolveStandingConversions({
+            brandId: 'brand-1',
+            credentialId: 'cred-1',
+            credentialName: 'LinkedIn Cred',
+            externalAccountId: '509410093',
+            requested: [{ ID: '30316052', Name: null }],
+        });
+        expect(noScopeRes).toEqual({
+            ok: false,
+            message: expect.stringContaining('rw_conversions'),
+        });
+        const noScopeIssues = await driver.validateProposal(program);
+        expect(noScopeIssues.some(i => i.code === 'LI_CONVERSION_SCOPE' && i.severity === 'error')).toBe(true);
+    });
+    it('keeps Google campaigns on account-default CUSTOMER goals under Maximize clicks (G1) and updates adopted campaigns only after platform writes succeed', async () => {
+        const fakeUser = { ID: 'u1' };
+        const deliveryCalls = [];
+        const customerGoalCalls = [];
+        let customGoalCalled = false;
+        let shouldFailDeliveryUpdate = true;
+        const storedRefs = [];
+        const driver = new GoogleAdsProgramDriver(fakeUser, async () => ({
+            ok: true,
+            brandConnectionId: 'bc-ga',
+            customerId: '4684433735',
+            brandAssets: null,
+            launchState: 'Paused',
+            defaultLocations: ['US', 'CA'],
+            defaultLanguages: ['en'],
+            client: {
+                findConversionActionById: async () => ({
+                    id: '7845520214',
+                    name: 'Ebook Form Submit',
+                    resourceName: 'customers/4684433735/conversionActions/7845520214',
+                    enabled: true,
+                    countsByDefault: false,
+                }),
+                findByName: async (resource) => resource === 'campaign' ? 'customers/4684433735/campaigns/777' : null,
+                createCampaignBudget: async () => 'customers/4684433735/campaignBudgets/11',
+                updateCampaignDeliverySettings: async (camp, opts) => {
+                    deliveryCalls.push([camp, opts]);
+                    if (shouldFailDeliveryUpdate)
+                        throw new Error('Simulated delivery update failure');
+                },
+                useCustomerConversionGoals: async (camp) => {
+                    customerGoalCalls.push(camp);
+                },
+                attachCampaignLocations: async () => { },
+                attachCampaignLanguages: async () => { },
+                excludeCampaignMobileApps: async () => { },
+                ensureCustomConversionGoal: async () => { customGoalCalled = true; return 'customers/4684433735/customConversionGoals/6459709271'; },
+                setCampaignConversionGoal: async () => { customGoalCalled = true; },
+                createAdGroup: async () => 'customers/4684433735/adGroups/22',
+            },
+        }));
+        const proposalIssues = await driver.validateProposal({
+            id: 'prog-ga-1',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Downloads',
+            params: {
+                campaignCode: 'CG-09',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    landingPageUrl: 'https://example.org/ebook',
+                    conversionId: '7845520214',
+                }),
+            },
+        });
+        expect(proposalIssues).toEqual([]);
+        driver['loadRefs'] = async () => storedRefs;
+        driver['runScheduleFor'] = async () => ({ start: 1_800_000_000_000 });
+        driver['saveRef'] = async (_pid, _bc, kind, urn, state) => {
+            const row = {
+                ExternalKind: kind,
+                ExternalURN: urn,
+                StateJSON: state ? JSON.stringify(state) : null,
+                Save: async () => true,
+            };
+            storedRefs.push(row);
+            return row;
+        };
+        const programArg = {
+            id: 'prog-ga-1',
+            brandId: 'brand-1',
+            hypothesis: 'h',
+            metricName: 'Downloads',
+            params: {
+                campaignCode: 'CG-09',
+                tacticConfigJSON: JSON.stringify({
+                    audience: 'targeted',
+                    dailyBudgetUsd: 25,
+                    maxCpcUsd: 2,
+                    landingPageUrl: 'https://example.org/ebook',
+                    conversionId: '7845520214',
+                }),
+            },
+        };
+        await expect(driver.onLock(programArg)).rejects.toThrow('Simulated delivery update failure');
+        const campaignRowAfterFail = storedRefs.find(r => r.ExternalKind === 'Campaign');
+        expect(JSON.parse(campaignRowAfterFail.StateJSON).bidding).toBeUndefined();
+        expect(JSON.parse(campaignRowAfterFail.StateJSON).goalConfigLevel).toBeUndefined();
+        shouldFailDeliveryUpdate = false;
+        await driver.onLock(programArg);
+        expect(deliveryCalls).toHaveLength(2);
+        expect(customerGoalCalls).toEqual(['customers/4684433735/campaigns/777']);
+        expect(customGoalCalled).toBe(false);
+        expect(JSON.parse(campaignRowAfterFail.StateJSON)).toMatchObject({
+            bidding: 'TARGET_SPEND',
+            maxCpcUsd: 2,
+            positiveGeoTargetType: 'PRESENCE',
+            goalConfigLevel: 'CUSTOMER',
+            optimizeFor: 'conversions',
+            locationsAttached: ['geoTargetConstants/2840', 'geoTargetConstants/2124'],
+            languagesAttached: ['languageConstants/1000'],
+            mobileAppsExcluded: true,
+        });
+        expect(JSON.parse(campaignRowAfterFail.StateJSON).conversionGoal).toBeUndefined();
+    });
 });
 //# sourceMappingURL=adConversionParity.test.js.map