@coframe/sdk 1.1.22 → 1.1.24

package/dist/pkg/cf.cjs.js

@@ -1079,7 +1079,7 @@ function warnEventsNotSent() {
     }
 }
 
-const SDK_VERSION = '2.7.0';
+const SDK_VERSION = '2.8.0';
 const queuedEvents = [];
 const queuedMonitoringEvents = [];
 const queuedSessions = [];
@@ -2277,7 +2277,7 @@ function isElementVisible(el) {
     return rect.top >= 0 && rect.bottom <= window.innerHeight;
 }
 const VALUE_UNKNOWN_YET = 'n/a';
-function checkActivationCondition(condition, personalizationHeaders, currentUrl, languages, browserPlatform, userToken, userVisitCount, runJsFunction, logger) {
+function checkActivationCondition(condition, personalizationHeaders, currentUrl, languages, browserPlatform, userToken, userVisitCount, runJsFunction, logger, options) {
     if (condition.and) {
         const results = condition.and.map((c) => checkActivationCondition(c, personalizationHeaders, currentUrl, languages, browserPlatform, userToken, userVisitCount, runJsFunction, logger));
         const hasUnknown = results.some((r) => r === VALUE_UNKNOWN_YET);
@@ -2567,7 +2567,7 @@ function checkAllAudiences(metadata, ctx) {
     }
     return result;
 }
-async function getVariantsAndElements(personalizationHeaders, project, previewVariantId, userToken, currentPageUrl, languages, browserPlatform, logger, nonce, laneClaims = {}, silentFallback = false) {
+async function getVariantsAndElements(personalizationHeaders, project, previewVariantId, userToken, currentPageUrl, languages, browserPlatform, logger, nonce, laneClaims = {}, silentFallback = false, chooseCmabVariants) {
     var _a;
     const experimentsInfo = [];
     const cloakBot = !!((_a = project.settings) === null || _a === void 0 ? void 0 : _a.bot_cloaking_enabled) &&
@@ -2595,7 +2595,7 @@ async function getVariantsAndElements(personalizationHeaders, project, previewVa
     const validatedClaims = validateClaims(laneClaims, project.lanes);
     const previewVariantIds = splitPreviewVariantIds(previewVariantId);
     if (previewVariantIds.length > 0) {
-        const variantsAndElements = previewVariants(previewVariantIds, validatedClaims, ctx, silentFallback);
+        const variantsAndElements = await previewVariants(previewVariantIds, validatedClaims, ctx, silentFallback);
         if (variantsAndElements) {
             return buildResponse({
                 variantsAndElements,
@@ -2635,7 +2635,7 @@ async function getVariantsAndElements(personalizationHeaders, project, previewVa
         final_state: false,
         level: GLOBAL_HOLDOUT,
     });
-    const assignment = assignFrames(activeFrames, validatedClaims, ctx);
+    const assignment = await assignFrames(activeFrames, validatedClaims, ctx, chooseCmabVariants);
     return buildResponse({
         ...assignment,
         experimentsInfo: [...experimentsInfo, ...assignment.experimentsInfo],
@@ -2651,7 +2651,8 @@ function activateFrames(ctx) {
         return true;
     });
 }
-function assignFrames(activeFrames, validatedClaims, ctx) {
+async function assignFrames(activeFrames, validatedClaims, ctx, chooseCmabVariants) {
+    var _a;
     const { project, userToken, logger } = ctx;
     const experimentsInfo = [];
     const variantsAndElements = [];
@@ -2677,6 +2678,7 @@ function assignFrames(activeFrames, validatedClaims, ctx) {
     }
     const excludedExperimentIds = resolveLaneWinners(validatedClaims, reachableByLane, project.lanes, userToken);
     const updatedClaims = { ...validatedClaims };
+    const assignmentEntries = [];
     let hasActivatedFrames = false;
     for (const frame of activeFrames) {
         let atLeastOneExperimentWasActivated = false;
@@ -2702,51 +2704,88 @@ function assignFrames(activeFrames, validatedClaims, ctx) {
             const experimentHoldoutInfo = metadata.holdout_info;
             const experimentUniverseVid = chooseVariant(userToken, experimentHoldoutInfo.variant_bins, experimentHoldoutInfo.seed, experimentHoldoutInfo.holdout_variant_id);
             if (experimentUniverseVid === experimentHoldoutInfo.holdout_variant_id) {
-                experimentsInfo.push({
-                    variant_id: experimentHoldoutInfo.holdout_variant_id,
-                    variant_slug: experimentHoldoutInfo.holdout_variant_slug,
+                assignmentEntries.push({
+                    kind: 'info',
+                    info: {
+                        variant_id: experimentHoldoutInfo.holdout_variant_id,
+                        variant_slug: experimentHoldoutInfo.holdout_variant_slug,
+                        experiment_id: experimentHoldoutInfo.holdout_experiment_id,
+                        experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
+                        iteration_id: '',
+                        level: EXPERIMENT_HOLDOUT,
+                        final_state: true,
+                        holdout_experiment_id: experimentHoldoutInfo.holdout_experiment_id,
+                        holdout_experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
+                    },
+                });
+                continue;
+            }
+            assignmentEntries.push({
+                kind: 'info',
+                info: {
+                    variant_id: experimentHoldoutInfo.treatment_variant_id,
+                    variant_slug: experimentHoldoutInfo.treatment_variant_slug,
                     experiment_id: experimentHoldoutInfo.holdout_experiment_id,
                     experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
                     iteration_id: '',
                     level: EXPERIMENT_HOLDOUT,
-                    final_state: true,
+                    final_state: false,
                     holdout_experiment_id: experimentHoldoutInfo.holdout_experiment_id,
                     holdout_experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
-                });
-                continue;
-            }
-            experimentsInfo.push({
-                variant_id: experimentHoldoutInfo.treatment_variant_id,
-                variant_slug: experimentHoldoutInfo.treatment_variant_slug,
-                experiment_id: experimentHoldoutInfo.holdout_experiment_id,
-                experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
-                iteration_id: '',
-                level: EXPERIMENT_HOLDOUT,
-                final_state: false,
-                holdout_experiment_id: experimentHoldoutInfo.holdout_experiment_id,
-                holdout_experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
+                },
             });
-            const variantId = chooseVariant(userToken, metadata.allocation, metadata.seed, '');
-            const variant = variants.find((v) => v.id === variantId);
-            if (!variant) {
-                logger.error(`Variant not found for experiment ${metadata.experiment_id}`, 'variant_not_found', {
-                    experiment_id: metadata.experiment_id,
-                });
-                break;
-            }
-            experimentsInfo.push({
-                variant_id: variant.id,
-                variant_slug: variant.slug,
+            assignmentEntries.push({ kind: 'variant', metadata, variants, elements });
+        }
+    }
+    const cmabMetadataById = new Map();
+    for (const entry of assignmentEntries) {
+        if (entry.kind === 'variant' && entry.metadata.type === 'CMAB') {
+            cmabMetadataById.set(entry.metadata.experiment_id, entry.metadata);
+        }
+    }
+    let mlVariantIds = new Map();
+    if (chooseCmabVariants && cmabMetadataById.size > 0) {
+        try {
+            mlVariantIds = await chooseCmabVariants(Array.from(cmabMetadataById.values()), userToken);
+        }
+        catch (_b) {
+            mlVariantIds = new Map();
+        }
+    }
+    for (const entry of assignmentEntries) {
+        if (entry.kind === 'info') {
+            experimentsInfo.push(entry.info);
+            continue;
+        }
+        const { metadata, variants, elements } = entry;
+        let mlVariantId = metadata.type === 'CMAB'
+            ? ((_a = mlVariantIds.get(metadata.experiment_id)) !== null && _a !== void 0 ? _a : null)
+            : null;
+        if (mlVariantId && !variants.some((v) => v.id === mlVariantId)) {
+            logger.warn(`CMAB variant ${mlVariantId} not in experiment ${metadata.experiment_id}`, 'cmab_variant_not_found', { experiment_id: metadata.experiment_id });
+            mlVariantId = null;
+        }
+        const variantId = mlVariantId ||
+            chooseVariant(userToken, metadata.allocation, metadata.seed, '');
+        const variant = variants.find((v) => v.id === variantId);
+        if (!variant) {
+            logger.error(`Variant not found for experiment ${metadata.experiment_id}`, 'variant_not_found', {
                 experiment_id: metadata.experiment_id,
-                experiment_slug: metadata.slug,
-                iteration_id: metadata.iteration_id,
-                level: EXPERIMENT,
-                final_state: true,
-                holdout_experiment_id: experimentHoldoutInfo.holdout_experiment_id,
-                holdout_experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
             });
-            variantsAndElements.push({ variant, elements });
+            continue;
         }
+        experimentsInfo.push({
+            variant_id: variant.id,
+            variant_slug: variant.slug,
+            experiment_id: metadata.experiment_id,
+            experiment_slug: metadata.slug,
+            iteration_id: metadata.iteration_id,
+            level: EXPERIMENT,
+            final_state: true,
+            holdout_experiment_id: metadata.holdout_info.holdout_experiment_id,
+            holdout_experiment_slug: metadata.holdout_info.holdout_experiment_slug,
+        });
+        variantsAndElements.push({ variant, elements });
     }
     return {
         variantsAndElements,
@@ -2755,7 +2794,7 @@ function assignFrames(activeFrames, validatedClaims, ctx) {
         laneClaims: updatedClaims,
     };
 }
-function previewVariants(previewVariantIds, validatedClaims, ctx, silentFallback) {
+async function previewVariants(previewVariantIds, validatedClaims, ctx, silentFallback) {
     const previewRollouts = previewVariantIds.includes(ROLLOUTS_PREVIEW_ID);
     const requestedVariantIds = previewVariantIds.filter((id) => !isPreviewSentinel(id));
     const requestedVariants = findVariants(ctx.project.frames, requestedVariantIds);
@@ -2768,7 +2807,7 @@ function previewVariants(previewVariantIds, validatedClaims, ctx, silentFallback
         window.alert(`[Coframe] Variant preview unavailable: ${previewVariantIds.join(',')}.`);
     }
     const rolledOutVariants = previewRollouts && !previewVariantIds.includes(GLOBAL_HOLDOUT)
-        ? assignFrames(keepRolledOutExperiments(activateFrames(ctx)), validatedClaims, ctx).variantsAndElements
+        ? (await assignFrames(keepRolledOutExperiments(activateFrames(ctx)), validatedClaims, ctx)).variantsAndElements
         : [];
     return uniqueByVariantId([...rolledOutVariants, ...requestedVariants]);
 }
@@ -2846,6 +2885,226 @@ function getNavigationType(isInitialApply) {
     return undefined;
 }
 
+const CMAB_ASSIGNMENT_TIMEOUT_MS = 500;
+const CMAB_ASSIGNMENT_MAX_EXPERIMENTS = 64;
+const ASSIGNMENT_REQUEST_SCHEMA = 'coframe.edge.assign-request/2';
+const ASSIGNMENT_RESPONSE_SCHEMA = 'coframe.edge.assign-response/2';
+async function requestAssignmentChunk(options, metadata, userToken) {
+    var _a, _b, _c, _d, _e;
+    const assignments = new Map();
+    const decisions = new Map();
+    let fallbackReason = 'request_failed';
+    let timeoutId;
+    let cancel;
+    try {
+        if (options.disableRemoteAssignment) {
+            fallbackReason = 'network_policy';
+            return { assignments, decisions };
+        }
+        const controller = new AbortController();
+        const budget = Date.now() + CMAB_ASSIGNMENT_TIMEOUT_MS;
+        const deadline = options.deadline !== undefined && options.deadline < budget
+            ? options.deadline
+            : budget;
+        const remaining = deadline - Date.now();
+        if (((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) || remaining <= 0) {
+            fallbackReason = ((_b = options.signal) === null || _b === void 0 ? void 0 : _b.aborted)
+                ? 'cancelled'
+                : 'deadline_exceeded';
+            return { assignments, decisions };
+        }
+        const cancelled = new Promise((resolve) => {
+            var _a;
+            cancel = () => {
+                var _a;
+                fallbackReason = ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+                    ? 'cancelled'
+                    : 'deadline_exceeded';
+                resolve(null);
+                controller.abort();
+            };
+            timeoutId = setTimeout(cancel, remaining);
+            (_a = options.signal) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', cancel);
+        });
+        const userContext = sanitizeUserContext(options.userContext);
+        const pending = fetch(`${"https://edge.cofra.me"}/api/v2/assign`, {
+            method: 'POST',
+            credentials: 'omit',
+            headers: { 'Content-Type': 'application/json' },
+            signal: controller.signal,
+            body: JSON.stringify({
+                schema: ASSIGNMENT_REQUEST_SCHEMA,
+                project_id: options.projectId,
+                user_token: userToken,
+                current_url: options.currentUrl,
+                referrer: options.referrer,
+                experiment_ids: metadata.map((item) => item.experiment_id),
+                ...(userContext ? { user_context: userContext } : {}),
+            }),
+        }).then((response) => {
+            if (!response.ok)
+                return null;
+            fallbackReason = 'invalid_response';
+            return response.json();
+        });
+        const payload = await Promise.race([pending, cancelled]);
+        if (controller.signal.aborted ||
+            ((_c = options.signal) === null || _c === void 0 ? void 0 : _c.aborted) ||
+            Date.now() >= deadline) {
+            fallbackReason = ((_d = options.signal) === null || _d === void 0 ? void 0 : _d.aborted)
+                ? 'cancelled'
+                : 'deadline_exceeded';
+            return { assignments, decisions };
+        }
+        if ((payload === null || payload === void 0 ? void 0 : payload.schema) !== ASSIGNMENT_RESPONSE_SCHEMA ||
+            !Array.isArray(payload.assignments)) {
+            return { assignments, decisions };
+        }
+        const requested = new Map(metadata.map((item) => [item.experiment_id, item]));
+        const seen = new Set();
+        for (const row of payload.assignments) {
+            if (!row || typeof row.experiment_id !== 'string')
+                continue;
+            const id = row.experiment_id;
+            const expected = requested.get(id);
+            if (!expected)
+                continue;
+            if (seen.has(id)) {
+                assignments.delete(id);
+                decisions.delete(id);
+                continue;
+            }
+            seen.add(id);
+            if (typeof row.iteration_id !== 'string' ||
+                row.iteration_id !== expected.iteration_id ||
+                (row.variant_id !== null && typeof row.variant_id !== 'string'))
+                continue;
+            assignments.set(id, row.variant_id);
+            const decision = {
+                experiment_id: id,
+                iteration_id: row.iteration_id,
+                variant_id: row.variant_id,
+            };
+            for (const key of [
+                'decision_source',
+                'fallback_reason',
+                'model_id',
+                'feature_spec_version',
+                'policy_id',
+                'policy_version',
+                'policy_route',
+                'active_model_failure',
+                'model_load_state',
+                'scored_by',
+            ]) {
+                if (typeof row[key] === 'string' && row[key].length <= 256)
+                    decision[key] = row[key];
+            }
+            if (typeof payload.assignment_request_id === 'string' &&
+                payload.assignment_request_id.length <= 256) {
+                decision.assignment_request_id = payload.assignment_request_id;
+            }
+            if (typeof row.assignment_probability === 'number' &&
+                row.assignment_probability >= 0 &&
+                row.assignment_probability <= 1) {
+                decision.assignment_probability = row.assignment_probability;
+            }
+            if (typeof row.decision_latency_ms === 'number' &&
+                row.decision_latency_ms >= 0 &&
+                row.decision_latency_ms < Infinity) {
+                decision.decision_latency_ms = row.decision_latency_ms;
+            }
+            if (Array.isArray(row.eligible_variant_ids) &&
+                row.eligible_variant_ids.length <= 256 &&
+                row.eligible_variant_ids.every((id) => typeof id === 'string' && id.length <= 256)) {
+                decision.eligible_variant_ids = row.eligible_variant_ids;
+            }
+            if (row.action_probabilities &&
+                typeof row.action_probabilities === 'object' &&
+                !Array.isArray(row.action_probabilities)) {
+                const keys = Object.keys(row.action_probabilities);
+                if (keys.length <= 256 &&
+                    keys.every((key) => key.length <= 256 &&
+                        typeof row.action_probabilities[key] === 'number' &&
+                        row.action_probabilities[key] >= 0 &&
+                        row.action_probabilities[key] <= 1)) {
+                    decision.action_probabilities = row.action_probabilities;
+                }
+            }
+            decisions.set(id, decision);
+        }
+        return { assignments, decisions };
+    }
+    catch (_f) {
+        return { assignments, decisions };
+    }
+    finally {
+        if (timeoutId !== undefined)
+            clearTimeout(timeoutId);
+        if (cancel)
+            (_e = options.signal) === null || _e === void 0 ? void 0 : _e.removeEventListener('abort', cancel);
+        for (const item of metadata) {
+            if (!decisions.has(item.experiment_id))
+                decisions.set(item.experiment_id, {
+                    experiment_id: item.experiment_id,
+                    iteration_id: item.iteration_id,
+                    variant_id: null,
+                    decision_source: 'client_fallback',
+                    fallback_reason: fallbackReason,
+                });
+        }
+    }
+}
+function createCmabVariantBatchChooser(options) {
+    const decisions = new Map();
+    const choose = async (metadata, userToken) => {
+        decisions.clear();
+        const uniqueMetadata = Array.from(new Map(metadata.map((item) => [item.experiment_id, item])).values());
+        const chunks = [];
+        for (let index = 0; index < uniqueMetadata.length; index += CMAB_ASSIGNMENT_MAX_EXPERIMENTS) {
+            chunks.push(uniqueMetadata.slice(index, index + CMAB_ASSIGNMENT_MAX_EXPERIMENTS));
+        }
+        const results = await Promise.all(chunks.map((chunk) => requestAssignmentChunk(options, chunk, userToken)));
+        const assignments = new Map();
+        for (const result of results) {
+            result.assignments.forEach((value, id) => {
+                assignments.set(id, value);
+            });
+            result.decisions.forEach((value, id) => {
+                decisions.set(id, value);
+            });
+        }
+        return assignments;
+    };
+    choose.getDecisions = (experiments) => {
+        const selected = [];
+        for (const info of experiments) {
+            const decision = decisions.get(info.experiment_id);
+            if (!decision ||
+                decision.iteration_id !== info.iteration_id ||
+                !info.final_state)
+                continue;
+            if (decision.variant_id === info.variant_id)
+                selected.push(decision);
+            else
+                selected.push({
+                    experiment_id: info.experiment_id,
+                    iteration_id: info.iteration_id,
+                    variant_id: info.variant_id,
+                    decision_source: 'client_fallback',
+                    fallback_reason: decision.variant_id === null
+                        ? decision.fallback_reason || 'missing_choice'
+                        : 'unsupported_variant',
+                    ...(decision.assignment_request_id
+                        ? { assignment_request_id: decision.assignment_request_id }
+                        : {}),
+                });
+        }
+        return selected;
+    };
+    return choose;
+}
+
 const CACHE_TTL_MS = 60 * 1000;
 const cache = new Map();
 function getCachedFrames(url) {
@@ -2972,7 +3231,7 @@ function observeUrlChanges(baseUrlMatch, onUrlChange) {
     patchHistoryMethod('replaceState');
 }
 
-function startSession(Coframe, cookiesEnabled, executionStartTime, personalizationHeaders, sessionContext) {
+function startSession(Coframe, cookiesEnabled, executionStartTime, personalizationHeaders, sessionContext, pageUrl = getCurrentPageUrl()) {
     const sessionPayload = [
         Coframe,
         Coframe.orgId,
@@ -2985,7 +3244,7 @@ function startSession(Coframe, cookiesEnabled, executionStartTime, personalizati
         getBrowserPlatform(),
         getBrowserLanguages(),
         getBrowserUserAgent(),
-        getCurrentPageUrl(),
+        pageUrl,
         getBrowserFignerprintInfo(),
     ];
     {
@@ -3375,12 +3634,14 @@ function setupSPANavigation(Coframe, project, config, previewVariantId, isSessio
     let navigationAbortController = null;
     observeUrlChanges(false, async (newPageUrl, _oldPageUrl) => {
         var _a;
-        await new Promise((resolve) => requestAnimationFrame(resolve));
-        infiniteLoopProtection = 0;
         if (navigationAbortController)
             navigationAbortController.abort();
         navigationAbortController = new AbortController();
         const { signal } = navigationAbortController;
+        await new Promise((resolve) => requestAnimationFrame(resolve));
+        if (signal.aborted)
+            return;
+        infiniteLoopProtection = 0;
         let pageProject = project;
         let pagePersonalizationHeaders = Coframe.personalizationHeaders;
         const cached = getCachedFrames(newPageUrl);
@@ -3408,7 +3669,7 @@ function setupSPANavigation(Coframe, project, config, previewVariantId, isSessio
         }
         if (signal.aborted)
             return;
-        await applyVariants(newPageUrl, pageProject, pagePersonalizationHeaders);
+        await applyVariants(newPageUrl, pageProject, pagePersonalizationHeaders, signal);
     });
 }
 function readLaneClaims() {
@@ -3441,15 +3702,33 @@ function persistLaneClaims(claims, logger) {
 }
 function createApplyVariants(Coframe, config, previewVariantId, isSessionVariant, executionStartTime, analytics, laneStore) {
     let isFirstApply = true;
-    return async (pageUrl, pageProject, personalizationHeaders) => {
+    let applicationId = 0;
+    return async (pageUrl, pageProject, personalizationHeaders, signal, deadline) => {
+        var _a;
+        const currentApplication = ++applicationId;
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return;
         const sessionId = isFirstApply ? Coframe.sessionId : generateUUID();
         const sessionContext = buildSessionContext(isFirstApply);
         isFirstApply = false;
+        const preview = resolvePreview(pageUrl, previewVariantId, isSessionVariant);
+        const chooseCmabVariants = createCmabVariantBatchChooser({
+            projectId: Coframe.projectId,
+            currentUrl: pageUrl,
+            referrer: (_a = config.referrer) !== null && _a !== void 0 ? _a : getBrowserReferrer(),
+            signal,
+            deadline,
+            disableRemoteAssignment: Boolean(config.projectUrl || config.ingestUrl),
+            userContext: config.userContext,
+        });
+        const { variantsAndElements, experimentsInfo, hasActivatedFrames, laneClaims, } = await getVariantsAndElements(personalizationHeaders, pageProject, preview.previewVariantId, Coframe.userToken, pageUrl, getBrowserLanguages(), getBrowserPlatform(), Coframe.logger, config.nonce, laneStore.claims, preview.isSessionVariant, chooseCmabVariants);
+        if ((signal === null || signal === void 0 ? void 0 : signal.aborted) ||
+            currentApplication !== applicationId ||
+            (signal && !urlsMatch(pageUrl, getCurrentPageUrl())))
+            return;
         Coframe.sessionId = sessionId;
         Coframe.personalizationHeaders = personalizationHeaders;
-        const preview = resolvePreview(pageUrl, previewVariantId, isSessionVariant);
         setIsPreviewVariant(!!preview.previewVariantId);
-        const { variantsAndElements, experimentsInfo, hasActivatedFrames, laneClaims, } = await getVariantsAndElements(personalizationHeaders, pageProject, preview.previewVariantId, Coframe.userToken, pageUrl, getBrowserLanguages(), getBrowserPlatform(), Coframe.logger, config.nonce, laneStore.claims, preview.isSessionVariant);
         laneStore.claims = laneClaims;
         persistLaneClaims(laneClaims, Coframe.logger);
         Coframe.experimentInfo = experimentsInfo;
@@ -3466,7 +3745,11 @@ function createApplyVariants(Coframe, config, previewVariantId, isSessionVariant
         else {
             replaceVariants(variantsAndElements, Coframe.orgId, Coframe.logger, config.nonce);
         }
-        startSession(Coframe, isCookiesEnabled, executionStartTime, personalizationHeaders, sessionContext);
+        const cmabDecisions = chooseCmabVariants.getDecisions(experimentsInfo);
+        startSession(Coframe, isCookiesEnabled, executionStartTime, personalizationHeaders, {
+            ...sessionContext,
+            ...(cmabDecisions.length ? { cmab_decisions: cmabDecisions } : {}),
+        }, pageUrl);
         analytics.resetBroadcasted();
         analytics.sendAnalytics();
     };
@@ -3484,7 +3767,7 @@ async function modifyPage(Coframe, configResult, projectResult, analytics) {
         return;
     const laneStore = { claims: readLaneClaims() };
     const applyVariants = createApplyVariants(Coframe, config, previewVariantId, isSessionVariant, executionStartTime, analytics, laneStore);
-    await applyVariants(getCurrentPageUrl(), cdnProject, personalizationHeaders);
+    await applyVariants(getCurrentPageUrl(), cdnProject, personalizationHeaders, undefined, (integrationStartTime || executionStartTime).getTime() + timeoutMs);
     if (!Coframe.variantsAndElements ||
         Coframe.variantsAndElements.length === 0) {
         revealPage();